初始化列表

前言

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

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;
};

二，初始化列表使用事项：

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次

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

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

class A {
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class B {
public:
	B(int a, int ref)
		:_b(a)
		, _r(ref)
		, _n(10)
	{}
private:
	A _b;    // 没有默认构造函数
	int& _r;   // 引用
	const int _n;  // const 
};

引用成员变量，const成员变量， 无默认构造函数的 自定义类型成员变量不能先定义再初始化，它们在初始化列表内定义，并且必须在定义时就初始化，因此必须在初始化列表内初始化。

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

一定会先使用初始化列表初始化

class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}

private:
		int _hour;
};

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)
    {}

    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  随机值

 答案当然是D啦，因为成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关嘛。

a2在下，a1在上，a2初始化时a1还未被初始化，a1仍是随机值，所以a2为随机值，a1则为1。

三，explicit关键字

1. 隐式类型转换

 double b = i；并不是将i直接赋值给b，而是用i创建了一个临时变量，再将临时变量赋值给b，i的值并未改变，

2. 避免单参构造函数的隐式类型转换

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

打个栗子：

class Date
{
public:

    // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
	Date(int year)
        :_year(year)
	{}

    // 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
    Date(int year, int month, int day)
        : _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;
};

int main()
{
	Date d1(2022);
	d1 = 2023;
	return 0;
}

d1 = 2023；同样发生隐式类型转换，编译器用d1对象构造了一个临时对象，用2023初始化该对象，再用临时对象去对d1进行拷贝构造。即先构造，再拷贝构造。这样悄悄发生的事情, 有时可以带来便利, 而有时却会带来意想不到的后果.

c++提供了关键字explicit，禁止通过构造函数进行的隐式转换。声明为explicit的构造函数不能在隐式转换中使用。可以避免不合时宜的类型变换。

使用事项：

1. explicit关键字只对有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了
2. 就是当除了第一个参数以外的其他参数都有默认值的时候, explicit关键字依然有效, 此时, 当调用构造函数时只传入一个参数, 等效于只有一个参数的类构造函数
3. 当类的声明和定义分别在两个文件中时，explicit只能写在在声明中，不能写在定义中
4. 将拷贝构造函数声明成explicit并不是良好的设计，一般只将有单个参数的构造函数声明为explicit，而拷贝构造函数不要声明为explicit