C++类和对象（初始化列表，友元，静态成员，内部类）

初始化列表

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

类对象调用构造函数是进行赋初值，而不是初始化，因为初始化只能初始化一次，但是构造函数体内可以进行多次赋值

注意：
1.每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2.引用类型的变量在定义时就必须初始化，所以引用成员变量必须使用初始化列表对其进行初始化。被const修饰的变量可以看成是一个常量，常量在定义的时候必须初始化，所以也必须使用初始化列表进行初始化。自定义类型成员（没有默认构造函数的自定义类型成员也必须在初始化列表进行初始化

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int num) //对象成员变量定义的地方
		:_ret(a)
		, _a1(num)
		, _n(10)
	{}
private:
	A _ret; // 没有默认构造函数
	int& _a1; // 引用
	const int _n; // const
};

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
1.严格来说对于内置类型，使用初始化列表和函数体内初始化是没有区别的
2.对于自定义类型最好使用初始化列表，因为这样效率更高
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

所以建议类中成员变量声明的顺序和初始化列表出现的顺序保持一致

explicit 关键字

double i = 0.34; int j = i; 这段代码会发生隐式类型转换，先产生一个临时变量，然后把i赋给临时变量，临时变量再去赋值j。C++对于单参构造函数也支持隐式转换。

	Date d1(2022); //标准的构造函数调用，定义有名对象
	Date d1 = 2022; //语法意义上是先构造，再拷贝构造，隐式类型转换，编译器优化后，直接调用构造函数，早期编译器会先执行Date tmp(2022),再执行Date d1(tmp);现在编译器做了优化，直接调用构造函数Date d1(2022)。

但是Date d1 = 2022这段代码可读性不是很好，所以可以用explicit修饰构造函数，这些就会禁止单参构造函数的隐式转换。
讲一下匿名对象，Date (2022)就是构造一个匿名对象，匿名对象生命周期仅仅在这一行。当我们需要使用一次某个对象，但是其它地方不在需要该对象的时候，如果我们直接构造一个具体对象，这无疑是一种很大的浪费，因为这个对象我们使用一次就不用了，而一个对象的生命周期是整个栈帧，所以我们可以使用匿名对象。

友元

友元分为：友元函数和友元类
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元函数

cout是一个全局类型的对象，类型是ostream，内置类型的对象能直接使用cout和cin输入输出，是因为库里面已经将它们的<<和>>重载好了，<<和>>能够自动识别类型，是因为它们之间构成了函数重载。

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
我们可以使用友元函数去重载operator<<

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
int main()
{
	Date d(2022, 7, 3);
	cin >> d;
	cout << d << endl;
	return 0;
}

如果在类内部将operator<<重载成成员函数，不使用友元函数是不能的。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。
注意
1.友元函数可访问类的私有和保护成员，但不是类的成员函数
2.友元函数不能用const修饰
3.友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4.一个函数可以是多个类的友元函数
5.友元函数的调用与普通函数的调用和原理相同

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

友元关系是单向的，不具有交换性。
如果在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递
如果A是B的友元，C是A的友元，则不能说明C是B的友元。

class A
{
	// 声明B是A的友元类
	friend class B;
public:
	A(int n = 0)
		:_a(n)
	{}
private:
	int _a;
};
class B
{
public:
	void Print(const A& a)
	{
		// 直接访问A类中的私有成员变量
		cout << a._a << endl;
	}
};

static成员

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

特性
1. 静态成员（成员函数和成员变量）为所有类对象所共享，不属于某个具体的对象，是存储再静态区的
2. 静态成员变量必须在类外定义，定义时不添加static关键字
3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问（突破类域就能访问，编译器编译时就会到类中去找它）
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值
所以类对象的大小不包括静态成员的大小

class A
{
public:
	static void Print()
	{
		cout << _a << endl; //报错，静态成员函数不能访问非静态成员（没有this指针）
		cout << _b << endl; //可以
	}
private:
	int _a; //非静态成员
	static int _b; //静态成员
};

上面说的静态成员可以用类名::静态成员或者对象.静态成员来访问，公有的静态成员可以这样访问，但是如果想访问私有的静态成员变量，这种方法就不可行了，我们可以在类里写一个公有的静态成员函数访问这个静态成员变量并返回，然后用类名::静态成员函数或者对象.静态成员函数就可以访问。


问题
1. 静态成员函数可以调用非静态成员函数吗？
不可以，没有this指针
2. 非静态成员函数可以调用类的静态成员函数吗？
可以，都在类里面，突破了类域
C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值

内部类(C++11)

如果一个类定义在另一个类的内部，这个类就叫做内部类。注意此时这个内部类是一个独立的
类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

内部类就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元，不能通过外部类的对象去访问内部类
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系