1 再谈构造函数

1.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值，以我们之前实现的Date类对象为例。

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

建议：

有时我们可以忽略数据成员初始化的和赋值之间的差异，但并非总是这样。
如果成员是const 或 引用变量的话，必须将其初始化。类似的如果存在自定义类型并且该类不存在构造函数时，也必须将其初始化。例如:

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

private:
	const int _year;
	int& _month;
	int _day;
	A a;
};
int main(){
	const Date a1(2024,2,24);

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

我们想要两个输出 1 1 ，但是程序实际输出了：

这就是因为初始化顺序的问题了，因为成员_a2在_a1前，所以先对_a2初始化，就造成了随机值。

注意：

1. 每个成员变量在初始化列表中只能出现一次（初始化只能一次）
2. 类中包括以下成员，必须在初始化列表进行初始化 ：
   引用成员变量
const成员变量
自定义类型成员（并且该类没有默认构造函数时）
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

1.3 explicit关键字

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

class Date
{
public:
// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
   explicit Date(int year)
   	:_year(year)
   	{}
private:
   int _year;
   int _month;
   int _day;
};
void Test()
{
   	Date d1(2022);
   // 用一个整形变量给日期类型对象赋值
   // 实际编译器背后会用2023构造一个无名对象，
   //最后用无名对象给d1对象进行赋值

}

 class Date
{
public:
// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，
//没有使用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);
// 用一个整形变量给日期类型对象赋值
// 实际编译器背后会用2023构造一个无名对象，
//最后用无名对象给d1对象进行赋值
		d1 = 2023;
// 将 1 屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，
//禁止了单参构造函数类型转换的作用
}

由于上述代码可读性不是很好，所以一般单参数的类构造都要使用explicit修饰。

2 static 静态成员

有时候类需要一些成员与类本身直接相关，而不是与类的各个对象保持联系。
例如，一个银行账户类对象可能需要一个数据成员来表示当前基准利率。在此例中，我们希望利率与类关联，而不是与类的每个对象关联。从实现效率的角度来看，没必要每个对象都储存利率信息。而且更加重要的是，一旦利率浮动，我们希望所有对象都可以使用新值。所以我们引入静态成员的概念。

2.1 概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

2.2 声明成员变量

我们通过在成员的声明之前加入关键字 static 就可以创建，和其他成员一样，静态成员也是可以被 public 或 private的。静态成员变量的类型可以是常量，引用，指针，类类型等。
并且，静态成员函数也不与任何对象绑定在一起，他们不包含this指针。作为结果，静态成员函数不能声明成const 的而且我们也不能在static 函数体内使用this指针。这一限制及适用于this的显式使用，也对调用非静态成员的隐式使用有效。

2.3 使用类的静态成员

使用时我们通过作用域运算符直接访问静态成员。
虽然静态成员不属于类的某个对象，但是我们依然可以使用类的对象、引用、或者指针来访问静态成员。如下：

class Date
{
public:
	Date(int year, int month, int day)
	:_year(year)
	,_month(month)
	,_day(day)
	{ }
static void count();
private:
	int _year;
	int _month;
	int _day;
};
void count(){
}；
int main(){
	Date d1;
	Date* d2 = &d1; 
	d2->count();
	d1.count();
	return 0;
}

2.4 定义静态成员

和其他成员函数一样，我们既可以在类内部也可以在外部定义。当在类外定义时，不需要重复写 static 关键字，该关键字只出现在类内部的声明语句。
和类的所有成员一样，当我们指向类外部的静态成员时，必须指明成员所属的类名。static 关键字则只出现在类内部的声明语句中
要确保对象只定义一次，最好的办法就是把静态成员的定义与其他非内联函数的定义于同一个文件中。

总结

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名 :: 静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！