类和对象（下篇）

初始化列表

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

初始化列表就是类对象定义的地方
可以看看下面的格式，实际上，初始化列表可以和构造混合着用，例如下面的注释部分

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

初始化列表中每个变量只能出现一次，因为只能初始化一次
另外，下面的3种成员必须放在初始化列表中初始化。
1，const修饰的成员
2，引用
3，自定义类型无默认构造函数

class A
{
public:
	A(int a)  //这里可以把初始化列表看成是构造函数，写了编译器就不会生成
		:_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int ref)
		:_aobj(a)
		, _ref(ref)
		, _n(10)
	{}
private:
	A _aobj; // 没有默认构造函数
	int& _ref; // 引用
	const int _n; // const
};

小结一下： 尽量去使用初始化列表去初始化成员变量，因为无论你是否使用初始化列表，自定义类型一定会去
使用自己的初始化列表去初始化。

下面的代码会输出“Time()”,说明使用了Time类的初始化列表，怎么理解呢？ 完全可以把全缺省的初始化列表理解为默认构造函数，对于自定义类型，会使用它自己的默认构造函数去初始化

class Time
{
public:
	Time(int hour = 0)     //这里可以理解就是默认构造函数
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};

class Date
{
public:
	Date(int day)
	{}
private:
	int _day;
	Time _t;
};

int main()
{
	Date d(1);
}

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

特殊的单个形参的构造函数和explicit关键字

先来看看这样的代码

class Date
{
public:
	Date(int year)
		:_year(year)
	{}

	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2018);  //这里是调用拷贝构造函数，很清楚没毛病
	d1.Print();
	d1 = 2019;  //但是这里是啥操作？ 居然用常量去赋值自定义类型Date类对象？ 不报错吗？
	d1.Print();  
	return 0;
}

我们运行了一下，发现确实没有报错，为什么呢？ 因为这里是一种单个形参构造函数的特殊情况，
这里编译器会用2019去构造一个无名对象，然后赋值给d1.
只对单个形参有这种情况，多个参数就不行了，

如果我们不想用这种特殊情况怎么操作呢?
只需要加上explicit关键字就可以禁止单参构造这种特殊类型转换

explicit Date(int year)
		:_year(year)
	{}

static成员

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

看看特性

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

看一个面试题：实现一个类，计算中程序中创建出了多少个类对象。
这里就要借助一下静态的成员变量，方法就是统计构造函数和拷贝构造函数调用多少次

class Date
{
public:
	Date()
	{
		_count++;
	}
	
	Date(const Date& d)
	{
		_count++;
	}

	static int Getcount() //静态的成员变量只能用静态的成员函数获取
	{
		return _count;
	}
private:
	static int _count;
};

int Date:: _count = 0;   //初始化静态的成员变量

int main()
{
	Date d1, d2;
	Date d3(d1);
	cout << Date::Getcount() << endl;
	return 0;
}

友元

友元分为：友元类和友元函数

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

特性：
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用和原理相同

用流插入和流提取举例

其实是这样的，
1，友元的目的是可以访问私有成员
2，全局函数是为了不让第一个参数cout传给this指针

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
public:
	Date(int year ,int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

private:
	int _year;
	int _month;
	int _day;
};

//可以这样理解cout == ostream ,out是cout的别名，放回类型是引用返回，因为出函数作用域cout不销毁
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << d._month << d._day << endl;
	return out;
}

int main()
{
	Date d1(2022, 5, 26);
	cout << d1;  //cin也是一样的，就不重复了
	return 0;
}

友元类：
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time
类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递
如果B是A的友元，C是B的友元，则不能说明C时A的友元。

class Date; // 前置声明
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员
public:                //但是时间类不能访问日期类
	Time(int hour = 10, int minute = 10, int second = 10)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
    int _month;
	int _day;
	Time _t;
};

int main()
{
	Date d1;
	d1.SetTimeOfDate(2022, 5, 26);
	return 0;
}

内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的
类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中
的所有成员。但是外部类不是内部类的友元。
特性：

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

class A
{
private:
	static int k;
	int h;
public:
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK，这里这样访问是没问题的，静态成员函数属于所有的类对象
			cout << a.h << endl;//OK ，h是非静态成员，必须这样访问
		}
	};
};

int A::k = 1;

int main()
{
	A::B b; //一个类就是一个作用域，我们定义的时候需要这样
	b.foo(A()); 
	return 0;
}