初始化列表

大部分时候成员变量在对象实例化的时候调用构造函数就整体定义了，注意此时只有定义，不算初始化。而定义后的值的值是在构造函数里面给的。我们知道构造函数可以执行很多语句，可以给成员变量多次赋值。此时就不能说在构造函数内部初始化了。
但是有些成员必须在定义的时候初始化。如果定义一个const成员变量，但是const成员变量规定不能在构造函数里面给他初始化而且const就只有一次初始化的机会。此时就可以在初始化列表给他初始化。
初始化列表的写法：

class Date
{
public:
	Date(int y)
		:_year(1)
		,_month(2)
		,_day(3)//初始化列表初始化的值
	{
		_year = y;
		//_day = 100;const无法在构造函数中改变
		cout << "Date(int y)" << endl;
	}
	Date(const Date& d)//拷贝构造也可以有初始化列表
		:_year(1)
		, _month(2)
		, _day(3)
	{
		cout << "Date(Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	const int _day;
};

在构造函数下面写初始化列表，来拷贝构造和构造函数都可以有初始化列表

祖师爷为了区分初始化和定义就设计了初始化列表，在初始化列表中初始化我们的成员变量。我们每一次定义对象执行构造函数时，会先走初始化列表，即使我们没写也会走初始化列表。 初始化列表给了初始值，如果没有初始值，在C++11中的打了补丁，给了缺省值，即在类声明的时候给的值，其实就是初始化时候要给的值，如果没有缺省值，那初始化就给默认值。

private:
	int _year = 10;
	int _month = 20;
	const int _day = 30;

如上，如果没有给初始化列表，初始值就是这些缺省值

建议能用初始化列表就用初始化列表，因为初始化列表是必走的。

注意:

1. const必须走初始化列表，因为const属性必须给予初始值, 必须使用初始化列表，这里说使用初始化列表是，必须给一个缺省值或者在初始化列表给一个值。
2. 引用必须走初始化列表，因为引用只能是一个对象的引用，一个对象可以有多个引用，但一个引用只能对应一个引用对象。从这个角度看，引用就像是一个常量一样。
   引用既可以给缺省值引用也可以在初始化列表进行引用

private:
	int _year;
	int _month;
	const int _day;
	int& yy = _month;

自定义类型也会走初始化列表，然后去调用自己的默认构造，如果他没有默认构造就会报错，这一点在之前写构造函数时提到过。但是有了初始化列表，我们在初始化列表里面给自定义类型参数，此时就不会报错。此时相当于直接定义然后调用了构造。

如下，如果我们不写初始化列表里面的a(1,2)，编译器就会报错，因为类A没有默认构造函数。但是如果在初始化列表里面写了的话，就相当于定义的对象，并且给了参数。然后走他的构造函数。

class A
{
public:
	A(int a, int b)
		:x(a+10)
	{
		cout << "A(int a, int b)" << endl;
		cout << x << endl;
	}
private:
	int x;
};

class Date
{
public:
	Date(int y)
		:_year(1)
		,_month(2)
		,_day(3)
		, yy(_month)
		,a(1,2)
	{
		_year = y;
		cout << "Date(int y)" << endl;
		cout << _day << endl;
	}
	Date(const Date& d)//拷贝构造也可以有初始化列表
		:_year(1)
		, _month(2)
		, _day(3)
		, yy(_month)
		, a(1, 2)
	{
		cout << "Date(Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	const int _day;
	int& yy = _month;
	A a;
};

int main()
{
	Date d1(1);
	return 0;
}

上述代码执行结果如下：

初始化列表主要解决的就是这三类问题:
引用成员变量，const成员变量，自定义类型成员(且没有默认构造函数）。就是那些不能在函数体内定义的成员变量。
其他的成员，可以在初始化列表，也可以在构造函数内初始化处理，但是建议在初始化列表里面处理。

另一个注意的点是：
初始化列表按照声明顺序初始化

class Date
{
public:
	Date(int y)
		:_month(2) 
		,_year(_month)
	{
		cout << _year << endl;
		cout << _month << endl;
	}
private:
	int _year;
	int _month;
};

int main()
{
	Date d1(1);
	return 0;
}

执行结果是

可以发现初始化列表先写了month，再写的year，但是year并没有使用month的值初始化自己。调试的时候也是执行的year行再执行的month行。

隐式转换

单参数的隐式类型转换

看下面代码理解隐式转换：

class Date
{
public:
	Date(int y)
	{
		cout << y << endl;
	}
private:
	int _year;
	int _month;
};

int main()
{
	Date d1(11);
	Date d2 = 12;
	return 0;
}

执行结果为

可以发现代码中Date d2 = 12;，是将一个整形赋值给了一个类类型。这样的写法就是隐式类型转换。但是前提是单参数构造函数，只有单参数构造函数才支持隐式类型转换。

转换原理： 整型12作为参数构造了一个临时对象，然后d2再通过临时对象进行拷贝构造，但是编译器会进行优化，同一个表达式的连续步骤的构造，一般会合二为一，此时不会去执行拷贝构造，如果上述代码写了拷贝构造也不会执行的。
但是当我真正去使用的时候会发现，编译器直接调用了构造函数，可以直接理解为将等号右边直接进行了传参。
比如改为下面代码

class Date
{
public:
	Date(int y)
	{
		cout << y << endl;
		cout << this << endl;
	}
	Date(Date& d)
	{
		d._month = 100;
	}
	void operator=(Date d)
	{
		cout << "void operator=(Date d)" << endl;
	}
	Date* Print()
	{
		cout << "Date* Print()" << endl;
		cout << this << endl;
		return this;
	}
private:
	int _year;
	int _month;
};

int main()
{
	Date d1(11);
	Date d2 = 12;
	cout << d2.Print() << endl;
	const Date& d3 = 13;
	int i = 10;
	double j = i;
	return 0;
}

执行结果就是

可以发现全部调用的都是构造函数

需要注意的地方有两点：

1. 并不是只有刚创建的是才会进行隐式类型转换。如果创建过后在进行赋值，此时执行的就是赋值运算符重载，如果没有写就会进行浅拷贝，若此时成员变量有const限制的变量时，编译器就会报错。在VS2022中会报1>D:\Desktop\cpp\Project1\Project1\main.cpp(432,5): error C2280: “Date &Date::operator =(const Date &)”: 尝试引用已删除的函数
   这是因为如果没有定义自定义的复制构造函数或复制赋值运算符，编译器会默认生成这些函数。但当这些函数尝试访问 const 成员时，由于它们不能被改变，因此编译器会将复制赋值运算符标记为“已删除”。 此时就没有默认生成拷贝构造，如果我们写了赋值运算符的重载，并且不牵扯const限制的变量，就不会在报错。
   比如下面代码，如果把注释去掉就不会报错了

class Date
{
public:
	Date(int y)
	{
		cout << "Date(int y)" << endl;
	}
	//void operator=(Date d)
	//{

	//}
private:
	int _year;
	int _month;
	const int _day = 1;
};

int main()
{
	Date d1(1);
	d1 = 3;
	return 0;
}

但是如果没有const限制的成员变量，就不会出现上述报错，此时还是像刚创建一样，进行隐式类型转换，但是接着执行的就是赋值运算符重载，并且不会像刚赋值一样被优化不去执行，是真的执行了赋值运算符重载。

2. 类型转换或者传值返回会产生临时变量，临时变量具有常性，所以引用不加const会报错

int main()
{
	Date d1(11);
	Date d2 = 12;
	const Date& d3 = 13;
	int i = 10;//这种赋值不产生临时变量
	const double j = i;
	return 0;
}

上述代码中d3是13临时对象的引用，13产生的临时对象具有常性，不能被改变，所以要加const，但是此时临时的，所以可能会产生野引用。但是const会延长临时对象的生命周期，临时对象在其引用的作用域结束后才会被销毁。 这里要注意，此外这句话不像Date d2 = 12; Date d2 = 12;会直接调用构造函数，传参然后创建d2对象。但是const Date& d3 = 13;是会产生临时变量的。这条语句不是创建对象，只要创建对象才会被优化。

i 赋值给 j ，i 会进行类型转换产生一个临时的具有常性的变量，然后赋值给 j ，此时 j 应该被const限制。不然是不正确的，但是有的编译器会优化，不会报错，VS2022就没有报错。
但是Date d2 = 12;按理来说也有一个具有临时对象，此时的拷贝构造的参数应该是const限制的，但是上面说了会优化为直接执行构造函数传参，所以这里也不存在这个错误了。

这种隐式类型转换使用的情况一般是下面这种：

void StackPush(Date d)
{
	//
}
StackPush(1);

这样写可以很方便的进行Push，而不需要创建一个对象再Push。

多参数的隐式类型转换

上面写的多参数的构造函数不能进行隐式类型转换，其实并不，只是要加限制，不能直接加个等号就进行赋值了。

class Date
{
public:
	Date(int y, int j)
	{
		cout << y << endl;
		cout << j << endl;
	}
	Date(Date& d)
	{
		d._month = 100;
	}
	void operator=(Date d)
	{
		cout << "void operator=(Date d)" << endl;
	}
private:
	int _year;
	int _month;
};

int main()
{
	Date d1(11, 111);
	Date d2 = { 12, 122 };
	const Date& d3 = { 13, 133 };
	int i = 10;
	double j = i;
	return 0;
}

要像上述代码，写一个大括号才能进行隐式类型转换，此时执行的流程和上面单参数的的执行过程是一样的。
如果类里含有类类型的成员变量，我们也可以使用上述方法给缺省值。

explicit关键字

explicit是C++中的一个关键字，它用来修饰只有一个参数的类构造函数，以表明该构造函数是显式的，而非隐式的。当使用explicit修饰构造函数时，它将禁止类对象之间的隐式转换，以及禁止隐式调用拷贝构造函数。
例如：

class Date
{
public:
	explicit Date(int y)
	{
		cout << y << endl;
		cout << this << endl;
	}
private:
	int _year;
	int _month;
};

此时就不能进行隐式类型转换了，多参数的也一样。

static

通过一个场景引出static
怎样统计我们调用了几次构造函数？
可以定义一个全局变量，在构造和拷贝构造里面进行加 1 操作。
如下：

int n = 0;
class Date
{
public:
	Date()
	{
		++n;
	}
	Date(const Date& d)
	{
		++n;
	}
private:
};

Date Func()
{
	Date a;
	return a;
}
int main()
{
	Date d1;
	Date d2;
	Func();
	cout << n << endl;
	return 0;
}

定义一个全局的n，每次进入构造就执行一次++n操作。但是执行后输出结果却是3次，其实应该是4次，在Func()函数的return时是传值返回，会执行一次拷贝构造，但是编译器认为没有人使用，返回了也没用，就不执行拷贝构造了，其实试的时候发现就算有对象承接，也不会执行，应该是优化的原因。并且定义为全局的可能会在不经意间被修改。总之，这种方式不靠谱。

于是可以使用static关键字，封装成静态的。static修饰的仍然是全局的，封装在类中，可以在全局使用，而且不会出现上述的被优化或者被修改的情况。
写法如下：

class Date
{
public:
	Date()
	{
		++n;
	}
	Date(const Date& d)
	{
		++n;
	}
//private:
	static int n;
};
int Date::n = 0;
Date Func()
{
	Date a;
	return a;
}
int main()
{
	Date d1;
	Date d2;
	Func();
	cout << Date::n << endl;
	return 0;
}

需要注意的是：
static修饰的变量不能给缺省值，因为它此时不是属于某一个对象，而是属于所有对象，属于整个类。 所以也不能在初始化列表初始化，初始化列表是初始化某一个对象的。但是static不是属于某一个对象的。而且要在类外面定义。类里面是声明。
可以理解为此时还是全局的一个静态变量，但是受到了类域和访问限定符的限制。
此时若要访问这个变量，就要加访问限定符，如下几种情况都是可以的：

int main()
{
	Date d1;
	Date d2;
	Date* ptr = nullptr;
	Func();
	cout << d1.n << endl;
	cout << d2.n << endl;
	cout << ptr->n << endl;
	cout << Date::n << endl;
	return 0;
}

此时访问的都是n，只要确定是哪个类就好，指定类确定或者通过对象确定都可以。像指向空的Date类型指针都可以访问的，因为n并不在ptr指向的地址，而是在静态区，这样访问知识为了让他突破类域，找到n在哪。
但是上述的访问也要在公有的情况下才可以，其实和全局的区别不大。所以没关系如果要是私有，就要用公有的函数才可以访问了。
如下：

class Date
{
public:
	Date()
	{
		++n;
	}
	Date(const Date& d)
	{
		++n;
	}
	int Getn()
	{
		return n;
	}
private:
	static int n;
};

int Date::n = 0;

Date Func()
{
	Date a;
	return a;
}
int main()
{
	Date d1;
	Date d2;
	Date* ptr = nullptr;
	Func();
	cout << d1.Getn() << endl;
	return 0;
}

同样可以把函数封装为静态的，如下：

class Date
{
public:
	Date()
	{
		++n;
	}
	Date(const Date& d)
	{
		++n;
	}
	static int Getn()
	{
		return n;
	}
private:
	static int n;
};
int Date::n = 0;
Date Func()
{
	Date a;
	return a;
}
int main()
{
	Date d1;
	Date d2;
	Date* ptr = nullptr;
	Func();
	cout << d1.Getn() << endl;
	cout << Date::Getn() << endl;
	return 0;
}

此时可以通过类进行访问这个函数，但是要注意，静态的成员函数没有this指针，此时要做的事情如果牵扯到this指针就无法执行。

其实由于VS2022编译器优化的过于厉害，用上述的static其实也无法正确统计调用的构造的次数，也可能是真的就调用了编译器返回的那么多次，那么多次可能对于编译器来说够了。编译器会有各种优化，并且会修改我们的代码，所以被优化导致不符合预期也是正常的。