【C++】- 类和对象（构造函数！！explicit关键字stastic关键字！！详解）

构造函数初始化列表

我们已经初步了解了构造函数------->类和对象②那么调用构造函数就是给了对象中各个成员变量一个合适的初始值。

但实际上，我们想要做的是初始化成员变量，在构造函数中对成员变量进行的赋值操作并不是对象的初始化，而只是给成员变量赋予了初始值。在构造函数体内部，可以多次对成员变量进行赋值操作，这与对象的初始化是不同的概念。

对象的初始化是指在创建对象时，为对象的成员变量分配内存空间并赋予初始值，这个过程只发生一次。而构造函数体内的赋值操作只是对已经存在的成员变量赋予新的值，这个过程可以在构造函数体内任意次数地进行。

举个例子来说明：

class MyClass {
public:
    int num;

    MyClass(int value) {
        num = value;  // 这是赋值操作，不是初始化
    }
};

MyClass obj(10);  // 创建对象，并调用构造函数

在上述例子中，构造函数MyClass(int value)中的num = value语句只是对成员变量num赋予了初始值，而不是对象的初始化。对象的初始化是在创建对象时，为成员变量num分配内存空间并赋予初始值，这个过程只发生一次。

需要注意的是，在C++11标准引入之前，我们无法在构造函数的初始化列表中直接对非静态成员变量进行初始化，只能在构造函数体内进行赋值操作。而在C++11以后，我们可以使用初始化列表来对成员变量进行初始化，这样更符合对象初始化的概念。

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟
一个放在括号中的初始值或表达式。

class MyClass {
public:
    int num;

    MyClass(int value) : num(value) {
        // 初始化列表中对成员变量进行初始化
    }
};

MyClass obj(10);  // 创建对象，并调用构造函数

在上述例子中，构造函数 MyClass(int value) 使用初始化列表对成员变量 num 进行了初始化，这是一种更优雅和高效的方式，它将赋值操作转化为了初始化操作。

还有需要注意的一点是，初始化列表的顺序应该与成员变量在类中声明的顺序一致，这样可以保证每个成员变量都能被正确地初始化。并且每个成员变量在初始化列表中只能出现一次

当类中包含以下成员时，必须放在初始化列表位置进行初始化：

• 引用成员变量
• const成员变量
• 自定义类型成员(且该类没有默认构造函数时)

另外，成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
次序无关

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}

在上面这段代码中，类A的构造函数使用了初始化列表来对成员变量进行初始化。构造函数中的Print函数用于打印成员变量的值。根据代码逻辑，在创建对象A aa(1)后，调用了Print函数进行输出。在Print函数中，会分别输出成员变量_a1和_a2的值。根据初始化列表的顺序，成员变量_a2在成员变量_a1之前进行初始化。因此，成员变量_a2的初始化使用了成员变量_a1的值。

因此，输出会是"1 1"。

explicit关键字

explicit是C++中的关键字，用于修饰类的单参数构造函数。它的作用是防止隐式类型转换，只允许显式地调用构造函数进行对象的创建。

在没有使用explicit关键字修饰的构造函数中，编译器会根据需要进行隐式类型转换。这可能导致一些意外的行为和错误的结果。使用explicit关键字可以避免这种隐式类型转换的发生。

下面是一个示例：

class MyClass {
public:
    explicit MyClass(int n) {
        // 构造函数体
    }
};

void func(MyClass obj) {
    // 函数体
}

int main() {
    MyClass obj1(10);  // 直接调用构造函数，显式地创建对象

    MyClass obj2 = 20;  // 错误！使用了隐式类型转换，编译错误

    func(30);  // 错误！使用了隐式类型转换，编译错误

    return 0;
}

在上述示例中，类MyClass的构造函数被explicit关键字修饰，它只能显式地被调用，不能进行隐式类型转换。

在main函数中，obj1直接使用构造函数显式地创建对象，是合法的。但是，obj2和func(30)都会导致编译错误，因为它们都尝试使用隐式类型转换调用构造函数。

使用explicit关键字可以避免一些潜在的错误，提高代码的可读性和安全性。

static成员

static成员是指在类中被声明为static的数据成员或函数成员。

static关键字用于将成员与类本身关联，而不是与类的每个实例对象关联。

对于static数据成员，它们被所有类的实例对象所共享，只有一个副本存在于内存中。它们可以用于在类的所有实例对象之间共享数据。static数据成员必须在类的定义体外进行初始化，并且不能在类的成员函数中直接访问非静态成员变量和成员函数。

对于static函数成员，它们属于类而不是对象，因此可以直接使用作用域解析运算符::来调用，不需要创建类的实例对象。static函数成员不能访问类的非静态成员变量和成员函数，只能访问类的静态成员变量和成员函数。

下面是一个示例：

#include <iostream>
using namespace std;

class MyClass {
public:
    static int count;  // 静态数据成员声明

    MyClass() {
        count++;  // 每次创建对象时增加count的值
    }

    static void PrintCount() {  // 静态函数成员声明
        cout << "Count: " << count << endl;
    }
};

int MyClass::count = 0;  // 静态数据成员定义和初始化

int main() {
    MyClass obj1;
    MyClass obj2;
    MyClass obj3;

    MyClass::PrintCount();  // 直接使用作用域解析运算符调用静态函数成员

    return 0;
}

在上述示例中，类MyClass定义了一个静态数据成员count和一个静态函数成员PrintCount。在main函数中，创建了三个MyClass类型的对象，每次创建对象时都会增加count的值。最终，通过MyClass::PrintCount()直接调用静态函数成员输出了count的值。

static成员可以用于在类的所有实例对象之间共享数据或方法，提高代码的效率和可维护性。但是，需要注意，在多线程编程中，对静态成员的并发访问可能会引发线程安全问题，需要进行适当的同步处理。