C++类和对象（3）

1、构造函数与初始化列表

  在创建对象时，编译器通过调用构造函数，给对象中的各个成员变量一个初始值如下所示：

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

这个过程不能称之为对类对象的初始化，因为初始化只有一次，而构造函数体内可以多次赋值，故C++有了初始化列表的概念。
  初始化列表：以冒号开始，以逗号分隔的数据成员列表，每个"成员变量"后面跟着一个放在括号中的初始值或表达式，表现形式如下：

class Date
{
public:
	Date(int year = 1, int month = 1 , int day = 1)
		:_year(year>10?10:2)
		,_month(month)
		,_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

初始化列表需要注意如下几点：
  1、每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）；
  2、类中包含以下成员，必须放在初始化列表位置进行初始化。
    1:引用成员变量(引用在定义时初始化)；
    2:const成员变量(const成员变量只能初始化一次)；
    3:自定义类型成员并且该类没有默认构造函数。

class Time
{
public:
			Time(int hour = 0)
			{
					_hour = hour;
			}
private:
			int _hour;
};

class Date
{
public:
			//初始化_t对象，可以在函数体内赋值，但还是会走初始化列表
			//调用Time的默认构造
			//Date(int year,int hour)
			//{
					//函数体内初始化
					//_year = year;
					//_Time t(hour);
					//_t = t;
			//}
			Date(int year,int hour)
					:_t(hour)
					{
						//函数体内初始化
						_year = year;
					}	
	private：
					int _year;
					Time _t;
};

总结：自定义类型成员推荐使用初始化列表进行初始化，初始化列表可以认为是成员变量定义的地方。

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，原因如下：
  成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

1.1、explicit关键字

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

class Date
{
public:
	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
	// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
	Date(int year)
		:_year(year)
	{}
	/*
	// 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修饰构造函数，禁止了单参构造函数类型转换的作用
}

2、static成员

2.1、静态成员概念

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

2.2、特性

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

class Stackonly
{
public:
	static Stackonly Createobj()
	{
		Stackonly so;
		return  so;
	}
private:
	Stackonly(int x = 0, int y = 0)
		:_x(x)
		,_y(0)
	{}
private:
	int _x = 0;
	int _y = 0;

};

int main()
{
	Stackonly so3 = Stackonly::Createobj();
	system("psuse");
	return 0;
}