初始化列表与Static成员

一、再谈构造函数

1.1构造函数体赋值

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

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

上述代码调用构造函数后，对象中已经有了一个初始值，但并不能将其称为对对象中成员变量的初始化，这只能称其为在构造函数体中对成员变量赋初始值，而不是初始化。因为成员变量的初始化只能在创建时初始化一次，而构造函数体中的进行多次赋值。

1.2初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号为分隔符的数据成员列表，每个“成员变量”后面跟一个放在括号中的初始值或表达式。

class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	Date(int year, int month, int day)//成员变量的初始化在进入函数体前就已经进行了
		:_year(year),
		_month(month),
		_day(day)   //不能使用等号如_day = day;
	{
		
	}
};

注： 

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

2.类中包含以下成员函数，必须放在初始化列表中初始化。

• 引用成员变量
• const成员变量
• 自定义类型成员（且该类没有默认构造函数时）

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

  

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

4.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中出现的先后次序无关

1.3explicit关键字

构造函数不仅可以构造与初始化对象，对于接收单个参数的构造函数，还具有类型转换的作用。接收单个参数的构造函数具体表现：

1.构造函数只有一个参数

2.构造函数有多个参数，除第一个参数没有默认值外，其余参数都有默认值

3.全缺省构造函数

类型转化：

class MyClass {
public:
	// 构造函数，可以接受 int 类型
	MyClass(int x) {
		cout << "MyClass(int x) " << x << endl;
	}
};
void printObject(const MyClass& obj) {
	cout << "printObject(const MyClass& obj)" << endl;
}
int main() {
	MyClass obj = 42;  // 隐式转换：int 转换为 MyClass 对象
	printObject(42);   // 隐式转换：int 被转换为 MyClass 对象
}

以上代码就是类型转换，但这种转换有时会发生不确定性的行为。因此explicit关键字就是用来禁止构造函数进行类型转换的。使用方法就是在构造函数前加上explicit

class MyClass {
public:
	explicit MyClass(int x) {
		cout << "MyClass(int x) " << x << endl;
	}
};
void printObject(const MyClass& obj) {
	cout << "printObject(const MyClass& obj)" << endl;
}
int main() {
	MyClass obj = 42;
	printObject(42); 
}

二、Static

2.1概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称为静态成员变量。用static修饰的成员函数，称为静态成员函数。静态成员函数必须在类的外面进行初始化

class A
{
public:
	static int ads() 
	{
		;
	}
private:
	static int _a; //声明
};
int A::_a = 0;//静态成员变量的初始化

2.2特性

1.静态成员是所有类对象共享的，不属于某个具体的对象，存放在静态区

class A
{
public:
	A() 
	{
		++_scount; 
	}
	A(const A& t) 
	{
		++_scount; 
	}
	~A() 
	{
		--_scount; 
	}
	static int GetACount() 
	{
		return _scount; 
	}
private:
	static int _scount;
};
int A::_scount = 0;
void TestA()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
}
int main()
{
	TestA();
	return 0;
}

 运行结果：

当取消static关键字时，代码如下：

class A
{
public:
	A(int a = 1) 
	{
		_a = a;
	}
	A(const A& t) 
	{
		_a = 3;
	}
	int GetACount() 
	{
		return _a;
	}
private:
	int _a;
};
void TestA()
{
	A a1, a2(2);
	cout << a1.GetACount() << endl;
	cout << a2.GetACount() << endl;
	A a3(a1);
	cout << a3.GetACount() << endl;
}
int main()
{
	TestA();
	return 0;
}

运行结果：

我们可以发现每个对象中都会生成一个_a成员变量，互不影响

2.静态成员变量必须在类外定义，定义是不添加static，类中只是声明

class A
{
public:
	static int ads() 
	{
		;
	}
private:
	static int _a; //声明
};
int A::_a = 0;//静态成员变量的初始化

3.类静态成员即可以类名::静态成员或对象.静态成员进行访问

4.静态成员函数没有隐藏的this指针，不能访问任何非静态成员

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