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

1.2、初始化列表

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

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using namespace std;
class A
{
public:
	1、
	//A(int x)
	//{
	//	_x=x;
	//}
 
	//2、
	A(int x)
		:_x(x)
	{}
private:
	int _x;
};
//5、
int value = 10; //全局变量、
class Date
{
public:
	1,在构造函数的函数体内进行初始化、
	//Date(int year = 1, int month = 1, int day = 1)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
 
	2,在初始化列表中进行初始化、
	//Date(int year = 1, int month = 1, int day = 1)
	//	:_year(year)
	//	, _month(month)
	//	, _day(day)
	//{}
 
	3,上述两种初始化方式可以混用(仅限于非静态类成员变量的部分情况)、
	//Date(int year = 1, int month = 1, int day = 1)
	//	:_year(year)
	//	, _month(month)
	//{
	//	_day = day;
	//}
 
	4、
	//Date(int year, int month, int day, int n, int value)
	//	: _n(n)
	//	, _value(value)//此时,整型变量value是局部变量,而非静态类成员变量_value是局部变量value的别名,而局部变量value出了该构造函数就会被销毁,所以继续进行优化、
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
 
	5、
	//Date(int year, int month, int day, int n)
	//	: _n(n)
	//	, _value(value)//此时,将整型局部变量value变为整型全局变量,具体见 Date类体外部 的上面、
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
 
	6、
	//Date(int year, int month, int day, int n)
	//	: _n(n)
	//	, _value(value)
	//	, _aa(10)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
	注意: 对于自定义类型的非静态类成员变量 _aa 而言,若他需要进行初始化时,只能在初始化列表中进行初始化,不能够在构造函数的函数体中进行初始化,
	当然,我们也可以选择让自定义类型的非静态类成员变量 _aa 不进行初始化,那么这时候,在初始化列表中还有该自定义类型的非静态类成员变量 _aa 的定义
	与其他非静态类成员变量不同的是,该自定义类型的非静态类成员变量_aa的定义(不传参),则可以自动调用它对应的默认构造函数,但此时,由于它对应的类体中
	并不存在默认构造函数,所以编译器会报错说是,不存在合适的默认构造函数可以使用,要想成功编译的话,可以在它对应的类体中提供默认构造函数即可,其次,
	如果就是不想在它对应的类体中提供默认构造函数的话,怎么做才能编译成功呢,此时,就需要让自定义类型的非静态类成员变量 _aa 进行初始化,并且只能在初始化列表中进行初始化、
 
	7、
	//Date(int year, int month, int day, int n, int a)
	//	: _n(n) //1
	//	, _value(value) //10
	//	, _aa(a) //15
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
	对于非静态类成员变量 _value和_n 而言,若要进行初始化的话,则只能在初始化列表中进行,若不进行初始化的话,那么在初始化列表中则会有这两者的定义,
	但与自定义类型的非静态类成员变量_aa不同的是,这两者的定义并不会自动调用它对应的默认构造函数,此时如果不对这两者在初始化列表中进行初始化的话,
	则编译器就会报错说是未对他们进行初始化,因此,这两个非静态类成员变量 _value和_n ,必须要在初始化列表中进行初始化才可以,对于除了这两种之外的
	非静态类成员变量在初始化列表中可以选择进行初始化,也可以选择不进行初始化、
	
	8、
	//Date(int year, int month, int day, int n, int a)
	//	: _n(n) //1
	//	, _value(value) //10
	//	, _aa(a) //15
	//	//, _year(year)
	//	//每个非静态类成员变量在初始化列表中只能出现一次,即初始化只能进行一次,不可以进行多次、
	//	//初始化列表可以认为就是类体中非静态类成员变量进行定义的地方，可以认为在初始化列表中，对类体中的所有的非静态类成员变量均进行了定义，在定义的地方进行的赋值操作称为初始化，并且初始化只能进行一次、
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
 
	//问:那么 初始化列表 存在的价值是什么?
	//像非静态类成员变量 _year,_month,_day ,即可以在构造函数的函数体内进行初始化,也可以在初始化列表中进行初始化,但是对于 某些 非静态类成员变量而言,
	//只能在初始化列表中进行初始化,即只能在其定义的地方进行初始化,具体见下面的总结、
private:
	//以下只是声明、
	//下面这些非静态类成员变量,能在初始化列表中进行初始化,即,能在定义的时候进行初始化,也可以在初始化列表中不进行初始化,即,在定义的时候不进行初始化
	//而是在构造函数的函数体内进行初始化、
	int _year;
	int _month;
	int _day;
	//上述三者均属于非静态类成员变量,均是声明,都在初始化列表中进行定义,但是,他们可以在初始化列表中进行初始化,也可以在构造函数的函数体中进行初始化、
 
	//下面这些非静态类成员变量,只能在初始化列表中进行初始化,即只能在定义的时候进行初始化、
	const int _n;  //此处关键字const修饰的非静态类成员变量也是声明,在初始化列表中进行定义,但是,只能在初始化列表中进行初始化、
	int& _value;   //此处的运算符&代表引用,也是声明,在初始化列表中进行定义,但是,只能在初始化列表中进行初始化、
	A _aa;         //自定义类型的非静态类成员变量,此处也是声明,在初始化列表中进行定义,但是,只能在初始化列表中进行初始化、
// //除了这三种非静态类型的类成员变量以外的其他的非静态类型的类成员变量,即可以在初始化列表中进行初始化,也可以在构造函数的函数体内进行赋值(初始化),准确来说,在构造函数的函数体内进行
// //的不能叫做初始化,而是叫做赋值,即,除了这三种非静态类型的类成员变量以外的其他的非静态类型的类成员变量,即可以在初始化列表中进行初始化操作,也可以在初始化列表中不进行初始化,而是在
// //构造函数的函数体内进行赋值操作、
 
	//int _year = 0; 
	//当我们在类体中不显式的实现构造函数(默认和非默认)时,则编译器会在类体中自动生成并调用一个无参的默认构造函数该无参的默认构造函数会对内置类型不做处理,对自定义类型
	//通过自动调用它对应的构造函数(默认和非默认)去进行初始化,这里的整型数字 0 ,并不代表的是进行初始化,因为这行代码只是进行的声明,并不为非静态类成员变量 _year 开辟内存空间,这里是缺
	//省值(C++11),这个缺省值,就是给初始化列表使用的,此时这行代码在初始化列表中等价于:  _year(0)  但是如果在构造函数(除编译器自动生成的无参的默认构造函数之外的所有构造函数)的形参列
	//表中拿到了局部整型变量 year 的值,不管是全缺省拿到的,还是外面传过来的,那么此时如果是在初始化列表中对非静态类成员变量_year进行初始化操作,则不会使用类体中非静态类成员变量 _year 
	//声明的这里的缺省值,他就是一个备胎,如果是在构造函数(除编译器自动生成的无参的默认构造函数之外的所有构造函数)的函数体内对非静态类成员变量_year进行初始化操作,那么此时应该是,在执
	//行初始化列表中的内容时,会先使用非静态类成员变量 _year 声明的这里的缺省值,然后当执行完初始化列表中的内容后,再执行构造函数(除编译器自动生成的无参的默认构造函数之外的所有构造函数)的
	//函数体中的内容,此时会再次把非静态类成员变量 _year 中的在初始化列表中使用的类体中非静态类成员变量 _year 声明的这里的缺省值的值替换掉,即,把非静态类成员变量 _year 声明的这里的缺省值替换掉、
 
	//总结: 有些非静态类成员变量只能在初始化列表中进行初始化,而有些非静态类成员变量能够在构造函数(除编译器自动生成的无参的默认构造函数之外的所有构造函数)的函数体中进行初始化,也可以在初始化列表中进行初始化
	//在此建议,把非静态类成员变量的初始化操作 尽量 都放在 初始化列表中 进行, 这是一定正确的、
};
int main()
{
	1、2、3
	//Date d1(2022,5,18);
	//此处是自定义类型的对象d1的定义,我们知道,对于非静态类成员变量均是属于某一个自定义类型的对象,所以当某一个自定义类型的对象进行定义时
	//那么该自定义类型的对象对应的类体中的非静态类成员变量才进行真正的定义,那这些非静态类成员变量具体在哪里进行的定义呢？
	//即,初始化列表可以认为就是类体中非静态类成员变量进行定义的地方,可以认为在初始化列表中,对类体中的所有的非静态类成员变量均进行了定义,
	//这是编译器自动完成的,我们不需要手动的去完成,我们只需要判断一下是否需要在初始化列表中对这些非静态类成员变量进行初始化即可、
 
	4、
	//Date d1(2022,5,18,1,2);
 
	5、
	//Date d1(2022, 5, 18, 1);
 
	6、
	//Date d1(2022, 5, 18, 1);
 
	7、
	//Date d1(2022, 5, 18, 1,15);
 
	8、
	//Date d1(2022, 5, 18, 1,15);
 
	return 0;
}
//注意:
//初始化列表只在构造函数(默认和非默认)中才会有,并且,当调用构造函数(默认和非默认)的时候,要先把初始化列表中的内容都执行完毕之后才会去执行该构造函数函数体中的代码
//要注意,在初始化列表中,对类体中的所有的非静态类成员变量均进行了定义,我们知道,如果我们在类体中不显式的实现构造函数(默认和非默认)的话,则编译器
//会在类体中自动生成一个无参的默认构造函数,还要知道,该无参的默认构造函数中的初始化列表中并没有显式的写出任何一个非静态类成员变量
//初始化的操作,即编译器自生成的无参的默认构造函数的初始化列表是空的,那么,所以编译器自动生成的无参的默认构造函数对内置类型不进行
//处理,而对自定义类型则是通过自动调用它对应的构造函数(默认和非默认)来进行初始化的意思就是说,在编译器自动生成的无参的默认构造函数
//中的初始化列表中,对类体中的非静态类成员变量均进行了定义,并且其初始化列表为空,所以在初始化列表中并没有对内置类型进行初始化,但是
//在初始化列表中却自动调用了自定义类型对应的默认构造函数,并且编译器自动生成的无参默认构造函数的函数体内也是空的,所以,在该
//函数体中也没有对类体中的内置类型进行初始化操作,这就构成了我们常说的,当我们不显式的在类体中实现构造函数时(默认和非默),那么编译器
//会在类体中自动生成并调用无参的默认构造函数,它对内置类型不做处理,对自定义类型则是通过自动调用它对应的默认构造函数进行初始化,
//总结: 如果某一个构造函数(默认和非默认)的初始化列表为空,且在该构造函数的函数体中对类体中的内置类型进行初始化操作的话,那么一定是先对类体中的自定义类型
//进行了初始化操作,后对类体中的内置类型进行了初始化操作、

  注意：

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using namespace std;
int ret = 10; //全局变量、
class A
{
public:
	A(int x)
		:_x(x)
	{}
	int _x;
};
class Date
{
public:
	Date(int year, int month, int day, int n,int a)
		: _year(year=1)
		, _month(month=2)
		, _day(day=3)
		,_n(n = 4)   //若为此操作,则优先使用  n=4 , 注意: 表达式 n=4 执行后的结果为 n ,其余5者同理、
		, _ret(ret=5)
		, _aa(a=6)
	{}
	void Print()
	{
		cout << _year << " " << _month << " " << _day << " " << _n << " " << _ret << " "<< _aa._x << endl;
	}
private:
	//此处的整型数字10,20,30,均用于初始化列表,但我们知道,在类体中,内置类型声明时赋缺省值的优先级比较低,当在初始化列表中已经显式的进行了初始化操作,则就不再使用这里声明处的缺省值、
	int _year = 10;
	int _month = 20;
	int _day = 30;
	int& _ret;
	const int _n ;
 
	//const int _n = 7;//此时为赋缺省值,不是初始化,即使为初始化也没关系,因为关键字const修饰的变量不能被修改,但是可以进行初始化,此时在初始化列表中即使不写:  ,_n(n=4)
	//也是可以的,因为,编译器会自动在初始化列表中加上代码: ,_n(7) 所以不会报错说是未在初始化列表中进行初始化操作、
	
	A _aa = 20;
	//对于部分(该自定义的类,类A的类体中的构造函数除形参列表中第一个位置上隐藏的this指针外，只有单个参数时)自定义类型的对象在类体(Date类)中声明时也可以进行赋缺省值的操作，具体见C++类和对象下的博客、
	//由于此处只是声明,不是定义,考虑隐式类型转换,但不考虑部分编译器在一个步骤(表达式)中连续调用构造加拷贝构造或者连续调用拷贝构造加拷贝构造的优化和关键字explicit的作用
};
int main()
{
	Date d1(2022, 5, 18, 10,100);
	d1.Print();
	return 0;
}

例题：

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using namespace std;
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(); // 1  -858993460
}
//A.输出: 1、1 
//B.程序崩溃
//C.编译不通过
//D.输出: 1、随机值
//答:
//答案选D,这是因为:
//非静态类成员变量在类体中声明的次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关
//故,在初始化列表中,先对非静态类成员变量 _a2 进行初始化操作,再对非静态类成员变量 _a1 进行初始化操作
//此时,在初始化列表中先执行代码: , _a2(_a1) ,而此时的非静态类成员变量 _a1 还未进行初始化操作,又因为
//自定义类型的对象aa是局部对象,故非静态类成员变量 _a1 的值就是一个随机值,则非静态类成员变量 _a2 得到
//的就是一个随机值,然后编译器再执行代码 :_a1(a) ,则非静态类成员变量 _a1 得到的就是整型局部变量a,即得
//到的结果就是整型数字1,故最后打印出来的就是: 1 随机值 
//还要知道,当调用构造函数(默认和非默认)时,都必须先要把初始化列表中的内容都执行完毕后,再去执行该构造
//函数的函数体中的代码、

1.3、explicit关键字

//#define _CRT_SECURE_NO_WARNINGS 1
//#include 
//#include   //在C++中会学习一个STL库中的string类、
//using namespace std;
//class Date
//{
//public:
//	/*explicit Date(int year)
//		:_year(year)
//	{
//		cout << "Date(int year)" << endl;
//	}*/
//
//	Date(int year)
//		:_year(year)
//	{
//		cout << "Date(int year)" << endl;
//	}
//
//	Date(const Date& d)
//	{
//		cout << "Date(const Date& d)" << endl;
//	}
//private:
//	int _year;
//};
因为是STL库中的string类,所以我们不需要手动的显式实现这里的string类,而是在STL库中
已经实现了这里的string类, string类属于自定义类型的类、
class string
{
public:
	string(const char* str)
	{}
};
//void Func(const string& s)
//{}
//int main()
//{
//	//Date d1(2022); //调用非默认的构造函数、
//	//Date d2 = d1;  //调用拷贝构造函数、
//	//Date d3(d1);   //调用拷贝构造函数、
//
//	Date d4(2022); //调用非默认的构造函数、
//
//	//隐式类型转换(构造函数(非默认,需要传一个实参)的形参列表中,除了隐藏的this指针外为单参数,才会考虑进行隐式类型转换)、
//	Date d5 = 2022; //(单参2022,多参数的话,就不考虑进行隐式类型转换了,比如: Date d5=2022,5,18; )、
//	//先使用整型数字2022去调用构造函数(非默认),构造一个自定义的Date类型的临时对象(已经定义完毕),再使用该自定义的Date类型的已经定义完毕的临时对象去调用拷贝构造函数,
//	//这是隐式类型转换本质上的原理,强制类型转换也是上述原理,但由于部分编译器会对这一块进行优化,比如:VS编译器,那么当执行代码: Date d5 = 2022; 时,就只调用了构造函数
//	//(非默认),直接使用整型数字2022对自定义类型的对象d5中的内置类型的类成员变量进行初始化操作,此时代码: Date d5 = 2022; 等价于: Date d5(2022); 不再调用拷贝构造函数、
//	//总结:
//	//1、若类体中显式实现的非默认的构造函数的函数名前面没有加关键字 explicit 的话,若编译器进行了优化,那么他是支持上述的只调用非默认构造函数,不调用拷贝构造函数、
//	//2、若类体中显式实现的非默认的构造函数的函数名前面加上了关键字 explicit 的话,若编译器进行了优化,那么他是不支持上述的只调用非默认构造函数,不调用拷贝构造函数,
//	//此时就会报错说是:不存在从 int 转换为 Date 的适当的构造函数(非默认)、
//
//	string s1("hello"); //调用非默认的构造函数、
//	string s2 = "hello"; //同上,隐式类型转换、
//
//
//	//以下内容均不考虑编译器对隐式类型转换的优化,也不考虑使用关键字 explicit 、
//
//	//Date& d6 = d4; //权限不变,可成功编译、
//	const Date& d6 = 2022;    //隐式类型转换、
//	//此时自定义类型的对象d6引用的并不是整型数字2022,而引用的是由整型数字2022调用非默认构造函数从而构造的自定义类型Date类型的临时对象,此时出了这一行代码,该临时对象
//	//不会被销毁,其生命周期会进行延续,只有当自定义类型的对象d6出了其作用域,那么该临时对象才会被销毁，而临时对象具有常属性,此时属于权限不变,可以编译成功,若此处不加
//	//关键字const的话,则属于权限放大,编译错误,此处是先调用一次构造函数,构造出自定义类型Date类型的临时对象,然后对该临时对象进行取别名,并非是再调用拷贝构造函数,所以
//	//编译器在此处并不会进行优化,即,不会把调用构造函数和取别名的操作合二为一、
//
//	Func(s1); //此时,对象s1和s2均属于自定义类型的对象,此时属于权限缩小,可以成功编译、
//	Func("hello");
//	//此时属于权限不变,也是隐式类型转换,Func函数的形参部分的自定义类型的局部对象s是对字符串"hello"调用构造函数(非默认),构造出来的自定义的string类型的临时对象进行的引用,而临时
//	//对象具有常属性,此时属于权限不变,可以编译成功,若Func函数中的形参部分不加关键字const的话,则属于权限放大,编译错误,此处也是先调用一次构造函数,构造出自定义类型string类型的临时对象,
//	//然后对该临时对象进行取别名,并非是再调用拷贝构造函数,所以编译器在此处并不会进行优化,即,不会把调用构造函数和取别名的操作合二为一、
//	return 0;
//}

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using std::cout;
using std::cin;
using std::endl;
class B 
{
public:
	B(int b = 0)
		:_x(b)
	{}
	int _x;
};
class A 
{
public:
 
	//在类A的类体中的 非静态类成员变量(对象) 声明处赋 缺省值 等价于如下所示:  
	//A()
	//	:_a(10)
	//	, _b(20)
	//	, _p((int*)malloc(4))
	//{}
 
	void Print()
	{
		cout << _a << endl;
		cout << _b._x << endl;
		cout << _p << endl;
		cout << _n << endl;
	}
private:
	//在C++11中,可以在类体中的 非静态类成员变量(对象) 声明处赋 缺省值 ,如下所示:
	//1、
	int _a = 10;  
 
	//2、
	B _b = 20;
	//对于部分(该自定义的类,类B的类体中的构造函数除形参列表中第一个位置上隐藏的this指针外，只有单个参数时)自定义类型的对象在类体(A类)中声明时也可以进行赋缺省值的操作，
	//具体见C++类和对象下的博客,由于此处只是声明,不是定义,考虑隐式类型转换,但不考虑部分编译器在一个步骤(表达式)中连续调用构造加拷贝构造或者连续调用拷贝构造加拷贝构造的优化和关键字explicit的作用
 
	//3、
	int* _p = (int*)malloc(4);
 
	//在C++11中, 不可以 在类体中的 静态类成员变量(对象) 声明处赋 缺省值 ,如下所示:
	//static int _n =10; //错误,因为这里的缺省值是用于初始化列表中进行初始化的,而静态类成员变量(对象)是在类外进行定义的,并不是在初始化列表中进行的定义、
	static int _n;  //静态类成员变量在类内声明、
};
int A::_n = 10;     //静态类成员变量在类外定义、 
int main()
{
	A a;
	a.Print();
	return 0;
}

2、友元

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

友元提供了一种突破封装的方式，有时提供了便利，但是友元会增加耦合度，破坏了封装，对于友元函数而言，也只能在类体外的友元函数的定义中使用类体中的私有或保护的类成员变量和类成员函数，但不管怎么样，友元函数和友元类均破坏了封装，故友元不宜多用、

2.1、友元函数

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using std::cout;
using std::cin;
using std::endl;
//前置声明、
class Date; //在此处声明 Date 是一个类的名字,关于 Date类 具体的定义可以去后面找、
//问:此处为什么要加一个前置声明 class Date; 呢？
//答:在Time类体中的对全局友元函数Print的声明中,出现了 const Date&d , 编译器不会从该Time类体中整体去查找Date类的声明或定义,而是直接向上查找 Date类的声明或定义
//这是因为 Date 是一个类名,注意这里不要和之前所说的在整个类体中查找,两者不一样,具体见类和对象的第一篇博客,其次,对于该类体中的对全局的友元函数Print的声明而言,是不会报错的
//这是因为,他是声明,并非是使用,而出现的 const Date&d 是使用,并非是声明、
class Time
{
	friend void Print(const Date& d, const Time& t); //声明,Print全局函数是Time类的友元函数,在Print全局函数的函数体内可以直接访问Time类的私有,保护和公有的类成员变量和类成员函数、
public:
	Time(int hour = 0, int minute = 0, int second = 0)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
 
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
	friend void Print(const Date& d, const Time& t); //声明,Print全局函数是Date类的友元函数,在Print全局函数的函数体内可以直接访问Date类的私有,保护和公有的类成员变量和类成员函数、
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Print(const Date& d, const Time& t)
{
	cout << d._year << "-" << d._month << "-" << d._day << endl;
	cout << t._hour << "-" << t._minute << "-" << t._second << endl;
}
int main()
{
	Date d1(2022, 5, 20);
	Time t1;
	Print(d1, t1);
	return 0;
}

2.2、友元类

友元类的经典使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using std::cout;
using std::cin;
using std::endl;
//前置声明、
//class Date; //不需要前置声明,因为此时的 friend class Date; 是进行的声明,并非进行的使用、
class Time
{
	friend class Date; //声明 日期类为时间类的友元类 ,则在日期类中的任何地方均可以直接访问Time类中的私有,保护和公有的类成员变量和类成员函数、
	//无论是友元类的声明还是友元函数的声明,均可以在所在类的类体中的任何位置进行声明、
	//注意:此时,在时间类中声明日期类为时间类的友元类,则在日期类中的任何地方均可以直接访问Time类中的私有,保护和公有的类成员变量和类成员函数,但是此时
	//没有在日期类的类体中的任何位置声明时间类是日期类的友元类,所以在时间类中的任何地方均不可以直接访问日期类中的私有和保护的类成员变量和类成员函数、
	//友元类(日期类)中的所有的类成员函数都可以看做是另一个类(时间类)的友元函数,都可以直接访问另一个类(时间类)中的私有,保护和公有的类成员变量和类成员函数、
public:
	Time(int hour, int minute, int second)
		: _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)
		, _t(1,2,3)
	{}
 
	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;
	return 0;
}

class A
{
	friend class B;
};
class B
{
	friend class C;
};
class C
{};
//此时在类C的类体中可以访问到类B的私有,保护和公有的类成员变量和类成员函数,但是不能在类C的类体中访问到类A的私有和保护的类成员变量和类成员函数、

3、内部类

3.1、概念及特性

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

注意： 内部类B就是外部类A的友元类，注意友元类的定义，内部类B中的任何一处均可以通过外部类A实例化出来的对象参数来访问外部类A中私有，保护和公有的类成员变量和类成员函数，但是外部类A不是内部类B的友元类、

特性：

1、 内部类可以定义在外部类中的  public 、 protected 、 private 都是可以的，若一个类B定义在另一个类A的内部，这个内部的类B就叫做内部类，此时可以控制内部类B的属性，但是如果不把类B放在类A的内部，那么此时类B的属性就相当于是公有，封装性较差、

2、注意：内部类中任何位置均可以直接访问外部类中的  static 、枚举成员，且不需要外部类的对象或者 类名、

3、当计算 sizeof( 外部类的类名或外部类的对象 ) 时 ，和内部类没有任何关系、

4、使用内部类的类名进行实例化其对应的自定义类型的对象时，要注意加上外部类的类名和域作用限定符，这是以内部类定义在外部类的公有属性下为前提的、

class A
{
public:
    class B
    {
        
    }
}
int main()
{
    A::B b1; //类B是类A的内部类、
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using std::cout;
using std::cin;
using std::endl;
class A 
{
public:
	class B	 //内部类,类B的属性到底为私有,保护还是公有,具体根据自己的需求去设定即可,类B天生就是类A的友元类(单向),
	{        //所以在类B的类体中的任意位置均可以直接访问类A的私有,保护和公有的类成员变量和类成员函数,类A不是类B的友元类,此时这种内部类关系和把类B定义在类A外面的全局区域中
	public:                                    //唯一不同的就是这里具有的天生的友元类的性质,除此之外,别无其他不同,此时类A中的内部类,类B受类A中的访问限定符的限制、
		void foo(const A& a)
		{
			cout << _k << endl;//OK
			cout << a._h << endl;//OK
		}
	private:
		int _b;
	};
private:
	static int _k;
	int _h;
};
int A::_k = 1;
int main()
{
	A::B b;
	b.foo(A());
	cout << sizeof(A) << endl;//4,静态类成员变量属于整个类,即属于由该类实例化出来的所有的对象,不属于某一个对象,所以在计算sizoef(A)时,不把静态类成员变量算进去
	//除此之外,内部类B也不算入,这是因为,在类A的类体中,并不存在使用自定义的类B实例化出来的自定义类型的对象,此时计算自定义的 类A 所占内存空间的大小,本质上计算的
	//是由该自定义类型实例化出来的自定义类型的对象所占内存空间的大小、
	return 0;
}

4、例题

4.1、例题1

方法一：

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using std::cout;
using std::cin;
using std::endl;
class Sum
{
public:
    Sum()
    {
        _ret += _n;
        _n++;
    }
    
    //尽量不使用友元、
    //方法一:
    //int GetRet()
    //{
    //    return _ret;
    //}
    
    //方法二:
    static int GetRet()
    {
        return _ret;
    }
private:
    static int _n;
    static int _ret;
};
int Sum::_n=1;
int Sum::_ret=0;
class Solution 
{
public:
    int Sum_Solution(int n) 
    {
        //方法:编译器自动调用n次构造函数来完成任务:
        //1.变长数组、
        Sum a[n]; //牛客和力扣上都支持变长数组、
        //使用自定义类型的类名Sum实例化一个自定义类型的对象的过程中,编译器会自动调用一次构造函数,
        //若使用自定义类型的类名Sum实例化出一个数组,该数组有n个元素,在该过程中,编译器会自动调用n次构造函数、
        //方法一:
        //return a[0].GetRet();
        //方法二:
        return Sum::GetRet();
        
        2、
        //Sum*p =new Sum[n];
    }
};
//由于静态类成员变量属于类,不属于某一个对象,而是属于由该类实例化出来的所有的对象,所以在main函数中即使
//还未通过该类名实例化出来某一个对象,那么类中的静态类成员变量也已经存在了,和全局变量,全局静态变量,局部静态变量
//一样,在main函数之前就已经为其在静态区上开辟了内存空间,只不过是他们的作用域不同而已,全局静态,局部静态,全局变量,
//类体中的静态,他们的生命周期都是整个工程,只不过是作用域不同而已,类体中的静态的作用域是在类体内,或者是在
//指定类域后的位置可以进行使用、
//全局静态变量和全局变量的区别:链接属性不同,在包含时,静态全局变量只能在当前文件中使用,而全局变量
//在所有地方均可使用,全局函数和全局静态函数也是如此,全局变量和全局函数可能会出现连接冲突的问题、

注意：

/由于静态类成员变量属于类,不属于某一个对象,而是属于由该类实例化出来的所有的对象,所以在main函数中即使
//还未通过该类名实例化出来某一个对象,那么类中的静态类成员变量也已经存在了,和全局变量,全局静态变量,局部静态变量
//一样,在main函数之前就已经为其在静态区上开辟了内存空间,只不过是他们的作用域不同而已,全局静态,局部静态,全局变量,
//类体中的静态,他们的生命周期都是整个工程,只不过是作用域不同而已,类体中的静态的作用域是在类体内,或者是在
//指定类域后的位置可以进行使用、
//全局静态变量和全局变量的区别:链接属性不同,在包含时,静态全局变量只能在当前文件中使用,而全局变量
//在所有地方均可使用,全局函数和全局静态函数也是如此,全局变量和全局函数可能会出现连接冲突的问题、

方法二：

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using std::cout;
using std::cin;
using std::endl;
class Solution
{
public:
	int Sum_Solution(int n)
	{
		//方法:编译器自动调用n次构造函数来完成任务:
		Sum a[n]; //牛客和力扣上都支持变长数组、
		//使用自定义类型的类名Sum实例化一个自定义类型的对象的过程中,编译器会自动调用一次构造函数,
		//若使用自定义类型的类名Sum实例化出一个数组,该数组有n个元素,在该过程中,编译器会自动调用n次构造函数、
		return _ret;
	}
private:
	class Sum //内部类,则此时,Sum类为Solution类的友元类、
	{
	public:
		Sum()
		{
			_ret += _n;
			_n++;
		}
	};
	static int _n;
	static int _ret;
};
int Solution::_n = 1;
int Solution::_ret = 0;

4.2、例题2

6、再次理解面向对象