【C++】探索C++中的类与对象（下）---深入理解C++中的关键概念与应用

在这里插入图片描述

🌱博客主页：青竹雾色间.
😘博客制作不易欢迎各位👍点赞+⭐收藏+➕关注

✨人生如寄，多忧何为 ✨

在C++编程中，有许多重要的概念和特性，包括构造函数、explicit关键字、静态成员、友元以及内部类。这些概念不仅仅是语言的一部分，更是设计和理解类和对象之间关系的关键。在本文中，我们将深入探讨这些概念，并通过一系列具体的代码示例来加深理解。

文章目录

一.构造函数
二.explicit关键字
三. 静态成员
四.友元
五.内部类

一.构造函数

构造函数负责初始化对象的各个成员变量。
- 可以通过构造函数体赋值，也可以使用初始化列表进行初始化。
- 使用初始化列表进行初始化更为高效，尤其是对于引用成员、const成员以及自定义类型成员等情况。

//构造函数体赋值
class Date
 {
 public:
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
 };
 //初始化列表
 class Date
 {
 public:
Date(int year, int month, int day)
//每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
        : _year(year)
        ,  _month(month)
        , _day(day)
    {}
 private:
  //成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
 int _year;
 int _month;
 int _day;
 };
 int main()
 {
// 对于自定义类型成员变量，一定会先使用初始化列表初始化
    Date d(1);
 }

二.explicit关键字

explicit关键字用于修饰构造函数，可以防止隐式类型转换，避免意外的行为发生。这对于构造函数只接受一个参数的情况尤其重要。

#include <iostream>

class MyClass {
private:
    int value;
public:
    // 构造函数
    explicit MyClass(int v) : value(v) {}

    int getValue() const { return value; }
};

void printValue(const MyClass& obj) {
    std::cout << "Value: " << obj.getValue() << std::endl;
}

int main() {
    MyClass obj(5);
    printValue(obj);  // 正常，显式调用printValue函数

    // 下面的代码会报错，因为explicit关键字禁止隐式类型转换
    // printValue(10);  // 错误，不能将int隐式转换为MyClass

    return 0;
}

三. 静态成员

静态成员是属于类的成员，而不是属于类的对象。

静态成员变量被所有类对象共享，不属于某个具体的对象,存储在静态区；成员变量属于每一个类，存储在对象里面。
静态成员变量必须在类外部初始化(定义时不添加static关键字，类中只是声明)，并可以通过类名或对象来访问。
类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
静态成员函数没有隐藏的this指针，不能访问任何非静态成员
静态成员也是类的成员，受public、protected、private 访问限定符的限制

#include <iostream>

class Counter {
private:
    static int count; // 静态成员变量
public:
    Counter() { count++; }

    static int getCount() { return count; }
};

int Counter::count = 0; // 初始化静态成员变量

int main() {
    Counter c1;
    Counter c2;
    std::cout << "Counter count: " << Counter::getCount() << std::endl; // 2
    return 0;
}

四.友元

友元提供了一种突破封装的方式，允许特定函数或类访问另一个类的私有成员。友元可以是函数或类，分别用于解决函数访问私有成员和类访问私有成员的情况。

#include <iostream>

class A {
private:
    int x;
    friend class B; // 声明B为友元类
public:
    A() : x(0) {}
};

class B {
public:
    void modifyA(A& obj, int val) {
        obj.x = val; // B可以访问A的私有成员x
    }
};

int main() {
    A a;
    B b;
    b.modifyA(a, 10);
    return 0;
}

五.内部类

概念：
如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：
内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：

内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系。

#include <iostream>

class Outer {
private:
    int x;
public:
    Outer(int value) : x(value) {}

    class Inner {
    public:
        void display(Outer& obj) {
            std::cout << "Value of x in Outer: " << obj.x << std::endl;
        }
    };
};

int main() {
    Outer o(5);
    Outer::Inner i;
    i.display(o); // 通过内部类访问外部类的成员x
    return 0;
}