一、再谈构造函数

构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体 内可以多次赋值。而真正的初始化可以使用初始化列表。

初始化列表

01_31 01 44 55

初始化列表的语法

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

#include<iostream>
using namespace std;
class Date
{
public:// 初始化列表Date(int year, int month, int day): _year(year), _month(month), _day(day){}// 初始化列表是每个成员变量定义初始化的位置Date(int year, int month, int day){// 赋值修改_year = year;_month = month;_day = day;}private:// 声明int _year ; int _month ;int _day;
};int main()
{// 对象实例化Date d1(2024, 1, 31);return 0;
}

必须放在初始化列表的成员

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

✅ 引用成员变量​

✅ const成员变量

✅自定义类型成员（且该类没有默认构造函数时）

🌰必须在初始化列表位置的例子:

#include<iostream>
using namespace std;
class A
{
public:A(int a = 0):_a(a){cout << "A(int a = 0)" << endl;}
private:int _a;
};
class Date
{
public:// 初始化列表是对每个定义的成员变量 进行初始化Date(int year, int month, int day,int& x):_year(year),_month(month),_day(day),_n(1),_ref(x)//,_aa(1)//如果不在初始化列表对自定义类型进行初始化，编译器会调自定义类型的默认构造如果该自定义类型，不存在自身的的构造函数就会报错 //在自定义类型不提供默认构造的情况下，就必须在初始化列表位置进行初始化,_aa(1){}
private:// 声明int _year ; int _month ;int _day;//注意 const修饰的成员变量,必须放在初始化列表位置进行初始化const int _n;//引用类型变量,必须放在初始化列表位置进行初始化int& _ref;//自定义类型,必须放在初始化列表位置进行初始化A _aa;
};int main()
{// 对象实例化Date d1(2024, 1, 31);return 0;
}

注意：

1.一个变量只能初始化一次

2.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使 用初始化列表初始化

#include<iostream>
using namespace std;
class Date
{
public:Date(int year, int month, int day)_year = year;_month = month;_day = day;：n(1){}private:int _year ; int _month ;int _day;const int _n;
};int main()
{Date d1(2024, 1, 31);return 0;
}

explict关键字的使用

单参数构造函数支持隐式类型的转换

class C
{
public:C(int x = 0):_x(x){}
private:int _x;
};
//C xx(1);//全局对象
class B
{
private:// 缺省值int a = 1;int* p1 = nullptr;int* p2 = (int*)malloc(4);//C cc1 = xx;  // 自定义类型成员只能借用全局对象赋初值，虽然可以，但是很费劲C cc2 = 2;//由于单参数构造函数支持隐式类型的转换，这里就可以用内置类型对自定义类型赋初值
};
int main()
{C cc1(1);//单参数构造函数支持隐式类型的转换（内置类型int 转 自定义类型C）C cc2 = 2;//本质：2构造出一个C的临时对象 再拷贝构造 ->编译器优化了，同一个表达式连续步骤的构造，一般被编译器合二为一//C& cc3 = 2;int i = 1;//double& d = i;//这两句被注释的代码会报错，因为类型转换会产生临时变量 临时变量就具有常性 所以需要加上 const 修饰const C& cc3 = 2;const double& d = i;//cc3、d都引用的是临时变量return 0;
}

如果不想隐式类型的转换发生，那么该场景下，就可以使用explicit关键字，加在构造函数函数前面。

现在来考虑多参数的情况：01_31 03 00 26

多参数构造函数支持隐式类型的转换

class A
{
public://explicit A(int a1, int a2) 不想支持隐式转换，可以加上关键字explicitA(int a1, int a2):_a1(a1),_a2(a2){}private:int _a1;int _a2;
};int main()
{// C++11A aa1 = { 1, 2 };const A& aa2 = { 1, 2 };return 0;
}

缺省值 的 形式 总结

class B
{
private://缺省值 的 形式 总结int _a = 1;int* p = (int*)malloc(4);A aa1 = {1,2};
}
int main()
{return 0；
}

一个题目

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.输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

答案：🐶

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

建议：声明次序和初始化列表中的次序尽量保持一致。