C++——初始化列表&&explicit关键字

1.再谈构造函数

对于构造函数有不了解的老铁可以看这篇文章哦：文章链接C++类和对象

1.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
public:
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量 的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

1.2 初始化列表

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

class Date
{
public:
    Date(int year, int month, int day)
        : _year(year)//
        , _month(month)
        , _day(day)
    {}
private:
    int _year;
    int _month;
    int _day;
};

【注意】

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化（即使你不调用）：

• 引用成员变量（正常情况下，声明的时候就必须要赋值，不赋值就会报错）
• const成员变量（正常情况下，声明的时候就必须要赋值，不赋值就会报错）
• 自定义类型成员(且该类没有默认构造函数时，必须在构造的时候使用初始化列表给这个自定义类型成员初始化，否则即使不调用构造函数也会报错)

我们来举一个例子：

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}
private:
	int _a2;
	int _a1;
};

class B
{
public:
	B()
	{}
private:
	A _aa;//没有默认构造
	int& _ref;//没有初始化
	const int a;//没有初始化
};

int main()
{
	return 0;
}

对应错误请看下图：

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

class Time
{
public:
    Time(int hour = 0)
        :_hour(8)
    {
        cout << "Time()" << endl;
    }
private:
    int _hour=0;
};
class Date
{
public:
    Date(int day)
    {}
private:
    int _day;
    Time _t;
};
int main()
{
    Date d(1);
}

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

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)//初始化顺序，先对_a2进行初始化,然而_a1还没有被赋值，所以是随机值，然后是_a1，把a的值赋值给_a1即可。
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;//声明顺序是先_a2后_a1
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}

上面的程序输出什么值呢？
A. 输出1 1
B.程序崩溃
C.编译不通过
D.输出1 随机值

1.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。这样的作用不理解的老铁可以看下面代码，Date类的构造函数如果去掉前面的explicit，那么d1 = 2023;就不会报错，用一个整形变量给日期类型对象赋值，实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值，但是在构造函数前面加上explicit，就禁止了这样单参构造函数的类型转换。

请看下面代码：

#include
#include
using namespace std;

class Date
{
public:
	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
	// explicit修饰构造函数，单参构造函数类型转换的作用，explicit去掉之后，代码可以通过编译
	explicit Date(int year)
		:_year(year)
	{}

	
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
	// explicit修饰构造函数，单参构造函数类型转换的作用，explicit去掉之后，代码才可以通过编译
	/*explicit Date(int year, int month = 1, int day = 1)
	: _year(year)
	, _month(month)
	, _day(day)
	{}*/
	
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1(2022);


	
	d1 = 2023;
	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

int main()
{
	Test();
	return 0;
}

但上述代码可读性不是很好，用explicit修饰构造函数，将会禁止构造函数的隐式转换。
***************************************************end ******************************************************
_______________________有哪里看不懂可以随时向博主提问 ___________________________
_______________________有错误的地方欢迎各位老铁批评指正 _________________________
***************************************************end ******************************************************