初始化列表的使用： 以⼀个冒号开始，接着是⼀个以逗号分隔的数据成

员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式。

但是函数体内也能对成员变量进行赋值，那么为什么还要初始化列表呢？

其实初始化列表可以认为是每个成员变量定义初始化的地方。

通过这句话我们来看看以下初始化需要注意的地方：

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

其实很好理解，既然它是成员变量定义的地方，而成员变量不可以重复定义，因此也不能重复出现。

可以看到编译器对重复出现的成员变量进行了报错：已初始化。

2.引用成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化。

这个也很好理解。像这三种变量，它们本身必须在定义时就进行初始化。而初始化列表就是它们定义的地方，所以它们在初始化列表中必须进行初始化：

(1)引用变量

对于未定义时未初始化的引用变量，编译器要求对齐进行初始化。

(2)const成员变量

至于被const修饰的的变量，定义初始化后就不能再改变，也就不能再赋值，所以必须在定义时就进行初始化。

(3)没有默认构造的类类型变量

如果一个类没有默认构造，那么它的对象在定义时就必须进行初始化，否则没有合适的构造函数供它使用。

对这三类变量正确的初始化可以如下：

class A
{
public:
	A(int x)
	{
		_a = x;
	}

private:
	int _a;
};

class Date
{
public:
	Date(int& y,int date=20140101)
		: year(y),
		  _date(date),
		  a(2014)
	{

	}
private:
	int& year;
	const int _date;
	A a;
};

3.在C++11中支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。

首先来看下面的一段代码：

class Date
{
public:
	Date(int year = 2014, int month = 12, int day = 3)
		: _year(),
		  _day(13)
	{

	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << "/" <<_date<<endl;
	}

private:
	int _year = 1000;
	int _month = 10;
	int _day = 10;
	int _date;
};

int main()
{
	Date d1(2024, 9, 6);
	Date d2;
	cout << "d1日期为：";
	d1.Print();
	cout << "d2日期为：";
	d2.Print();
	return 0;
}

来看看结果和你想的是否一样：

(1).首先，我们要区分构造函数参数列表的缺省值和成员变量声明处的缺省值

参数列表的缺省值是给你在初始化对象时调用构造函数是否需要传参用的，而成员变量声明处的缺省值，是用来给没有初始化的成员变量用的。

如果你参数列表的值没有赋值给成员变量，那么成员变量的值不会受到改变，这就是为什么d1初始化时是(2024,9,6),但是d1和d2的实际结果相同。

(2).为什么_year的值是0而不是1000？为什么_date是随机值？

在C++其实int也有构造函数，在初始化列表中，我们显式写了_year()，这一过程编译器会调用int的默认构造函数将_year赋值为0。

而_date我们没有在初始化列表中显式写出，则不会调用构造函数，那么就是随机值。

(3)._month为什么是10？_day为什么是13而不是10。

在初始化列表中，我们没有显式写出_month，这时如果在声明中有缺省值，就会用缺省值对_month进行赋值。

而_day在初始化列表中被我们显式地写出，进行了初始化，就不会再去使用在声明中的缺省值。

4.对于没有显式在初始化列表初始化的自定义成员变量，编译器会调用它们自己的默认构造函数。如果没有默认构造函数，编译器会报错。

无论我们是否显式地写出初始化列表，每个构造函数都有初始化。无论我们是否在初始化中显式写出某个成员变量，每个成员变量都会走一遍初始化列表。

总结一下成员变量走初始化列表的各种情况：

5.初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。所以建议声明顺序和初始化列表顺序保持⼀致。

我们用一道题目来加深理解：

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

我们来看看上面代码的输出结果：

首先，初始化列表按照成员变量的声明顺序进行初始化。所以第一个进行初始化的成员变量是_a2，此时将_a1的值赋给_a2，但这个时候_a1还未进行初始化，因此_a1的值是随机值，所以_a2也是随机值。

第二个进行初始化的值是_a1，将a的值赋给_a1，而a的值为1，所以_a1的值也为1。

所以这道题的答案为1和随机值，选D。

---

二、类型转换

1.C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。

在上面的代码中就发生了隐式类型转换。在A a=2这句代码中产生了一个A类型的临时变量，2赋值给这个临时变量，这个临时变量再赋值给a。换句话说，2构造了一个A类型的临时对象，这个临时对象拷贝构造给a，而编译器遇到连续构造加上拷贝构造会直接优化成直接构造，意思是直接对a进行构造不用临时对象。

我们还能对这个临时对象进行引用：

因为临时对象具有常性，而我们引用的就是临时对象，所以需要加上const。

在C++11后我们还能进行多个参数的类型转换：

2.我们还能进行不同类类型对象之间的转换，需要相应的构造函数支持

class B
{
};

class A
{
public:
	A(int x)
	{
		_a = x;
	}

	A(int x, int y)
	{
		_a = x;
		_aa = y;
	}

	A(B b)//隐式转换需要相应的构造函数支持
	{
		_b = b;
	}
private:
	int _a;
	int _aa;
	B _b;
};

int main()
{
	A a = { 1,1 };

	//不同类类型对象之间的隐式转换
	B ab;
	A aa = ab;
	return 0;
}

3.在构造函数前面加explicit就不再支持隐式转换：

可以看到加入了explicit关键字后，编译器对隐式转换进行了报错。

---

三、static成员

静态成员就是静态成员变量和静态成员函数，首先来看看它们共同的特性：

1.静态成员也是类的成员，受public、protected、private 访问限定符的限制。

2.突破类域就可以访问静态成员，可以通过类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数。

class A
{
public:
	static int GetX()
	{
		return _ax;
	}

	static int _az;

private:
	static int _ax;
	static int _ay;
};

int A::_ax=1;
int A::_ay=2;
int A::_az=3;

int main()
{
	A a;
	cout << A::_az << endl;
	cout << A::GetX() << endl;
	cout << a._az << endl;
	cout << a.GetX << endl;
}

来看在类中静态成员变量的几个特性：

1.用static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进行初始化。

class Date
{
private:
	static int _year;
	static int _month;
	static int _day;
};

int Date::_year;
int Date::_month;
int Date::_day;