C++类零碎tips

初始化列表

之前我们知道了C++的类中有构造函数，可以对对象进行初始化，但是实际上虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表初始化

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

#include<iostream>

using namespace std;
class A
{
public:
	A(int a)//如果不给缺省值，则无法进行自定义
	{
		_a = a;
	}
private:
	int _a;
};
class Date
{
public:
	//初始化列表—每个成员变量定义的地方
	Date(int year, int month, int day,int i)//不是每个都需要进行初始化，但是每个变量只能初始化一次
		:_year(year)
		,_month(month)
		,_day(day)
		,_N(10)
		,ref(i)
		,_aa(10)//该结构体没有给缺省值的情况下，需要在这里进行初始化
	{
		//_N = 10;//这里报错说明到构造函数体内时，变量已经定义出来了
	}
private:
	int _year;//声明
	int _month;
	int _day;
	const int _N;//常量必须在定义的时候初始化
	int& ref;//引用
	A _aa;//没有默认构造函数的自定义类型
};

int main()
{
	int i = 0;
	Date d(2022, 3, 28,i);//对象定义/对象实例化
	//const int i;//报错 需要进行初始化
	return 0;
}

使用场景及注意事项

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：引用成员变量，const成员变量
   自定义类型成员(该类没有默认构造函数)
   普通成员变量类型在哪初始化都可以
   尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
   内置类型的成员，在函数体和初始化列表初始化都是可以的
   自定义类型的成员，推荐在初始化列表初始化因为这样更高效

初始化顺序

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

#include<iostream>

using namespace std;
class A
{
public:
	A(int a)
		:_a1(a)//_a2先初始化
		, _a2(_a1)
	{}

	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};

int main() 
{
	A aa(1);
	aa.Print();
	return 0;
}

这里的打印结果_a1成功被初始化为1，但是_a2并没有被初始化，是因为_a2先于_a1初始化。因此建议声明顺序和初始化顺序最好一致。

explicit关键字

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

使用场景

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
	void print()
	{
		cout << _year << endl;
	}
private:
	int _year;
};

int main()
{
	Date d1(2022);
	Date d2 = 2022;//隐式类型转换-表示意义相似的类型
	//原理是用2022构造一个临时对象Date(2022),再用这个对象拷贝构造d2
	//但是C++编译器在连续的一个过程中，多个构造会被合二为一，所以会变为一个构造
	d2.print();
	return 0;
}

但是这种隐式类型转换会使得代码的可读性变差，因此为了避免发生隐式类型转换，我们可以使用explicit关键字来修饰构造函数，这样将会禁止单参构造函数发生隐式转换。

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
	//给构造函数加上explicit可以让隐式类型转换无法发生
	explicit Date(int year)
		:_year(year)
	{}
	void print()
	{
		cout << _year << endl;
	}
private:
	int _year;

};

int main()
{
	Date d1(2022);
	Date d2 = 2022;//隐式类型转换-表示意义相似的类型
	d2.print();
	return 0;
}

此时，如果想再发生隐式类型转换，编译器将会报错。

static成员

特性

1. 静态成员为所有类对象所共享，不属于某个具体的实例
2. 静态成员变量必须在类外定义，定义时不添加static关键字
3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值

代码范例

#include<iostream>

using namespace std;
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		_count++;

	}
	//静态成员函数没有this指针，只能访问静态成员变量和成员函数
	static int Getstatic()
	{
		//_a;//没有this指针不能访问私有成员变量
		return _count;
	}
private:
	int _a;
	//类的成员函数可以随便访问
	static int _count;//静态成员变量属于整个类，所有对象，生命周期在整个程序运行期间
	//声明
};

int A::_count = 0;//定义初始化

int main()
{
	A a(10);
	//如果是公有类型可以直接在类外面访问
	//cout << A::_count << endl;
	//cout << a._count << endl;
	//私有需要提供接口函数进行访问
	cout << a.Getstatic() << endl;

	return 0;
}

C++11的成员初始化

C++11支持了一种新的语法，在声明变量的时候给变量一个缺省值，但是并没有进行初始化，如果有构造函数则时候构造函数进行初始化，如果没有则使用该缺省值

#include<iostream>

using namespace std;

class B
{
public:
	B(int b=1)
	{
		_b = b;
	}
private:
	int _b;
};

class A
{
private:
	//非静态成员变量，可以在声明的时候给缺省值，与缺省参数类似，但是不是初始化，如果有构造函数进行初始化则使用构造函数的值
	int _a = 1;
	B _b;
};

int main()
{
	A a;//正常内置类型不会进行初始化
	return 0;
}