C++：类和对象（下篇----初始化列表，explicit关键字，static成员，C++11 类成员的初始化，友元，内部类）

类和对象（下篇）

一、初始化列表

类和对象中篇我们了解了构造函数，构造函数可以定义为全缺省的构造函数，构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表的特点

初始化列表我们可以认为是变量定义的地方。

1. 以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
2. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
3. 引用类型成员变量、const修饰的成员变量、类类型成员(该类没有默认构造函数) 必须在初始化列表初始化（因为引用类型成员变量、const修饰的成员变量都是必须在定义的时候初始化，引用类型我必须要知道引用的是谁，const如果最开始不给值的话后面也没有办法对其改变，而类类型成员变量是自定义类型成员，如果没有默认构造函数的话，编译就不通过，因此如果没有默认构造函数的初始值的话就必须要在初始化列表进行初始化）

class A
{
public:
	A(int a)
	{
		_a = a;
	}
private:
	int _a;
};
class B
{
public:
	B(int ref = 0)
		:_ref(ref)
		, _n(10)
		, _a(0)
	{}
private:
	int& _ref;
	const int _n;
	A _a;
};
int main()
{
	B b1;
	system("pause");
	return 0;
}

4. 关于类类型成员，也就是自定义类型成员变量，一定会先使用初始化列表初始化，但是对于自定义类型则不会初始化，如下，_day没有初始化，但是_t在初始化列表被初始化为10

class Time
{
public:
	Time(int hour=0)
		:_hour(hour)
	{
		std::cout << "Time()" << std::endl;
	}
private:
	int _hour;
};

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

int main()
{
	Date d(1);
	system("pause");
	return 0;
}

5. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序
   如果顺序写的不对的话就会出现问题，如下方代码，导致malloc开辟的空间不是size*int个字节了，这就是因为初始化列表的顺序不对。

class Array
{
public:
	Array(int size)
		:_size(size)
		, _array((int*)malloc(sizeof(int)*_size))
	{}
private:
	int* _array;
	int _size;
};

二、explicit关键字

explicit关键字是用于修饰构造函数的，explicit修饰的构造函数会禁止单参数构造函数的隐式类型转换。（注：它只适用于单参数）
具体看下方代码：

class Date
{
public:
	Date(int year = 1900)
	{
		_year = year;
		std::cout << "Date(int year = 1900)" << std::endl;
	}
	Date(const Date& y)
	{
		_year = y._year;
		std::cout << "Date(const Date& y)" << std::endl;
	}
private:
	int _year;
};
int main()
{
	Date y1(2018);//构造
	Date y2 = y1;//拷贝构造
	Date y3 = 2019;//1.构造一个临时对象 2.把临时对象拷贝构造给y3  3.优化 <--->相当于构造
	system("pause");
	return 0;
}

这一段代码运行的结果如下：

我们发现这里y1对象调的是构造，y2对象调的是拷贝构造。
y3对象看起来也是构造，但是它做了三件事情：

1. 用2019 构造 了一个临时对象
2. 用这个临时对象 拷贝构造 y3对象
3. 编译器对该语句实现优化，让它就相当于是构造

实际上y3对象这里就发生了隐式类型的转换，因为2019是int型，而y3是Date类型，也就是这里实际上就是一种类型的转换。如果我们不想允许这种事情的发生我们就给构造函数加上explicit关键字。
给构造函数加上explicit关键字之后，Date y3=2019;这样有隐式类型转换的语句就会编译不通过。报错如下：

因此总结一下，explicit关键字就是修饰构造函数的，防止出现单参数构造函数的隐式类型的转换。

三、static成员

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

面试题：实现一个类，计算中程序中创建出了多少个类对象

class A
{
public:
	A()
	{
		++n;
		std::cout << "A()" << std::endl;
	}
	A(const A& a)
	{
		++n;
		std::cout << "A(const A& a)" << std::endl;
	}
	//设为静态的是因为如果没有产生对象也可以调用（没有this指针）
	static int Getn()//通过函数接口获取n的值
	{
		return n;
	}
private:
	static int n;//n的声明（n属于整个类，也属于这个类的每个对象）
};

int A::n = 0;//n的定义初始化（静态成员变量在类外定义初始化）

A f(A a)
{
	return a;
}
int main()
{
	A a1;
	A a2;
	f(a1);
	std::cout << A::Getn() << std::endl;
	system("pause");
	return 0;
}

static修饰成员变量或成员函数的特性

1. 静态成员为所有类对象所共享，不属于某个具体的实例（也就是说static修饰的成员变量属于整个类，同时也属于这个类的每个对象）
2. 静态成员变量必须在类外定义，定义时不添加static关键字
3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员（也就是说static修饰的成员函数没有this指针，可以无对象进行调用，如std::cout << A::Getn() << std::endl;，不能访问任何非静态成员是因为非静态成员都是私有的，要使用this指针进行访问，而静态成员函数是不用对象也可以调用的，导致封装出现问题）
5. 静态成员和类的普通成员一样，也有public、protected、private 3种访问级别，也可以具有返回值，const修饰符等参数

综上我们可以理解为：静态成员变量或者静态成员函数是这个类把全局的变量和全局的函数封装到了类里面，成员则属于整个类，函数也可以不用对象来调用。

【问题】

1. 静态成员函数可以调用非静态成员函数吗？
   不可以，因为静态成员函数没有this指针，调用非静态成员的话，非静态成员函数需要this指针。
2. 非静态成员函数可以调用类的静态成员函数吗？
   可以，因为非静态函数有this指针，如果在它里面调用静态成员函数（无this指针）的话也不会影响什么。

四、C++11 的成员初始化

C++11支持非静态成员变量在声明时，直接初始化。
这个初始化的值可以理解为是缺省值，如果有传递的值的话就用我传递的值，如果我没有传递的话就用这个缺省的值。

class B
{
public:
	B(int b = 0)//单参数的构造函数
	{
		_b = b;
	}
	int _b;
};
class A
{
public:
	void Print()
	{
		std::cout << a << std::endl;
		std::cout << b._b << std::endl;
		std::cout << arr << std::endl;
		std::cout << n << std::endl;
	}
private:
	//非静态的成员变量可以在声明的时候直接初始化
	//以下是成员变量的声明，并不是定义（后面的值相当于缺省值）
	int a = 10;
	B b = 20;//发生了隐式类型的转换
	int* arr = (int *)malloc(4);
	static int n;
};
int A::n = 30;//静态成员变量在类外进行初始化
int main()
{
	A a;
	a.Print();
	system("pause");
	return 0;
}

五、友元

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

友元函数

对于一个对象来说，我们不能采用cout<<直接输出。如下

我们如果想要用cout<<直接输出，就要进行运算符<<的重载。那么先看这么一段重载代码。
前提说明：以下代码因为我没有展开命名空间，所以使用cout/endl以及ostream/istream等都要加上域作用限定符std，大家如果觉得麻烦不想加域作用限定符的话可以在最开始将命名空间std展开，使用using namespace std;。（个人建议有些项目还是不要展开命名空间好一点，防止一些命名冲撞，所以尽量从点滴就养成这种命名空间的好习惯嘻嘻嘻(*･ω< ) ）

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	void operator<<(std::ostream& out)//重载<<操作符
	{
		out << _year << "-" << _month << "-" << _year << std::endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

这样写在类里面的操作符重载，有一个隐含的this指针是第一个参数，我们要知道是输入还是输出，因此我们需要传递的参数是cout或cin，但是我们把cout当做参数传递给操作符重载函数的时候，隐含的this指针是第一个参数，cout就变成了第二个参数，因此函数调用就变成了这样：

int main()
{
	Date d(2018, 2, 2);
	d.operator<<(std::cout);//原始调用
	d << std::cout;//精简调用
	system("pause");
	return 0;
}

这样的调用违背了我们的逻辑，可读性也不强。那我们想要像平时一样使用cout该怎么办呢？那我们就想到了针对这种情况要传两个参数的话，在类外面定义重载函数就可以，但是在类外面定义重载函数的话又不能访问类中的私有成员变量，这样就矛盾了，那又该怎么办呢？于是我们引入友元，友元就是可以突破封装的一种方式。

我们将上面的代码进行优化：

引入友元函数

class Date
{
	friend std::ostream& operator<<(std::ostream& out, const Date& d);//把operator<<这个函数定义为该Date类的友元
public:
	Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
//在类外定义该函数，函数参数第一个为左操作数，第二个为右操作数
//返回值为cout的别名，支持连续输出
std::ostream& operator<<(std::ostream& out,const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._year;
	return out;
}
int main()
{
	Date d(2018, 2, 2);
	std::cout << d << std::endl;//这样就可以像平时一样使用
	system("pause");
	return 0;
}

如上代码就可以让cout像正常一样使用了，代码可读性也变得很强，同时也可以输出某个对象，可以自己控制输出的形式。

基于此再次完善代码，实现cin>>输入的操作符重载。

class Date
{
	friend std::ostream& operator<<(std::ostream& out, const Date& d);
	friend std::istream& operator>>(std::istream& in, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
std::ostream& operator<<(std::ostream& out,const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day << std::endl;
	return out;
}
std::istream& operator>>(std::istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}
int main()
{
	Date d1,d2;
	std::cin >> d1 >> d2;
	std::cout << d1 << d2;
	system("pause");
	return 0;
}

友元函数的特点

1. 友元函数可访问类的私有成员，但不是类的成员函数（我们可以理解为是类的朋友）
2. 友元函数不能用const修饰（因为它没有this指针）
3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4. 一个函数可以是多个类的友元函数，一个类也可以有多个友元函数
5. 友元函数的调用与普通函数的调用和原理相同

友元类

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

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

class Date; //前置声明
class Time
{
	friend class Date;
	//声明日期类为时间类的友元类，则在日期类中就可以直接访问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
{
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)
	{
		// 直接访问Time时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

六、内部类

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

特性：

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

class A
{
private:
	static int k1;//声明
	int h=10;
public://B类的访问限定符是公有的，可以先找到A再找到B
	class B//B类默认是A类的友元类，因此B类可以访问A类的成员变量
	{
	public:
		static int k2;//声明
		int y;
		void f(const A& a)
		{
			std::cout << k1 << std::endl;//k1是静态成员变量，因此可以直接访问
			std::cout << a.h << std::endl;//h属于某一个对象，因此需要用对象来访问
		}
	};
};
int A::k1 = 10;//A类的静态成员变量的初始化
int A::B::k2 = 2;//通过A类找到B类，在类外进行初始化
int main()
{
	A::B b;//定义一个B类的b
	b.f(A());
	std::cout << sizeof(A) << std::endl;
	std::cout << sizeof(A::B) << std::endl;
	system("pause");
	return 0;
}

上述的代码里，B是A的内部类，两个类里面的静态成员变量都要在类外进行初始化，并且要加上域作用限定符。B默认是A的友元类，因此B可以访问A中的成员变量。sizeof(A)是4，sizeof(A::B)也是4，求类的大小的时候不会计算内部类，同时静态成员处于整个类，也不予计算。