文章目录
一、再谈构造函数
构造函数体赋值
在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体 内可以多次赋值。而真正的初始化可以使用初始化列表。
初始化列表
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) 不想支持隐式转换，可以加上关键字explicit
A(int a1, int a2)
:_a1(a1)
,_a2(a2)
{}
private:
int _a1;
int _a2;
};
int main()
{
// C++11
A 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 随机值
答案：🐶
原因：成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
建议：声明次序和初始化列表中的次序尽量保持一致。