前言

前两期我们将类和对象的重点讲的差不多了，这一篇文章主要进行收尾工作将类和对象其他的知识点拉出来梳理一遍，并且补充前两篇没有讲过的小细节。

一、构造函数中的初始化列表

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

 为什么加入了一个const变量就无法引用默认的构造函数了呢？

我们都知道，const成员在定义的时候必须初始化，前面我们介绍过可以加缺省值，但是缺省值也不是初始化，那么到底在哪初始化呢？这就要介绍到构造函数的初始化列表了，初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式。

class A
{
public:
	//1.哪个对象调用初始化函数，初始化列表是它所有成员变量初始化的地方
	//2.不管是否显示在初始化列表写，编译器会让每个变量都在初始化列表定义初始化
	A()
		:_x(1)
		,_a2(1)
	{
		_a1++;
		_a2--;
	}
private:
	int _a1 = 1;   //声明  使用缺省值并不是初始化
	int _a2 = 2;
	const int _x ;
};
int main()
{
	A aa;   //对象整体的定义，每个成员什么时候定义呢？
	return 0;
}

 那么大家可以猜一猜a1和a2的值分别是多少呢？当我们给初始化的时候就不用缺省值了，所以在初始化列表中a2被初始化为1，而a1没有初始化所以用了缺省值1，a1++后变成了2，a2--后变成了0，所以答案是2和0.

 初始化列表中，const修饰的变量，引用类型和自定义类型（没有默认构造的自定义类型）都必须在初始化列表初始化，不然编译器会报错，并且自定义类型初始化回去调用其自定义类型的构造函数。

class B
{
public:
	B()
		:_b(1)
	{
		cout << "B()" << endl;
	}
private:
	int _b;
};
class A
{
public:
	//1.哪个对象调用初始化函数，初始化列表是它所有成员变量初始化的地方
	//2.不管是否显示在初始化列表写，编译器会让每个变量都在初始化列表定义初始化
	A()
		:_x(1)
		,_a2(1)
		,ret(_a1)
		,_bb()
	{
		_a1++;
		_a2--;
	}
private:
	int _a1 = 1;   //声明  使用缺省值并不是初始化
	int _a2 = 2;
	//有三类变量必须在初始化列表初始化
	const int _x ;
	int& ret;
	B _bb;
};

 那么如果自定义类型是带参的构造函数我们该如何初始化呢？

这种带参的我们只需要在括号内传个值即可，编译器会去调用它的构造函数初始化。

注意：初始化列表中每个成员只能出现一次，因为初始化只能一次不能初始化两次。

建议：尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

下面我们看一道题：

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();
}

上面这道题答案应该是什么呢？首先我们定义了对象A并且调用构造函数传了1过去，这时候大多数人会认为a1先被初始化为1，然后s2被a1初始化也是1，但其实结果并不是这样。有这样一条规则：成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后顺序无关。也就是说初始化的顺序是看谁先声明的，谁先声明谁就先初始化，所以在上面那道题中a2先声明所以a2先用a1初始化，而这个时候的a1是随机数，所以a2被初始化为随机数，然后a1进行初始化，a1用a初始化所以a1是1，那么答案就是1和随机值。

拷贝对象时的一些编译器优化

下面我们讲一下编译器的优化：

class A
{
public:
	A(int a)
		:_a1(a)
	{}
private:
	int _a2;
	int _a1;
};
int main() {
	A aa(1);
	A aa2 = 1;
}

 为什么我们能直接用1去初始化aa2呢？要知道1是整形，而aa2是自定义类型，其实这里包含了编译器优化，首先我们要知道这里是隐式类型转换，就像下图：

在这里是直接把i给d吗？其实不是，这里会先开一个double的临时变量，并且临时变量具有常性，先将i给这个double类型的临时变量，然后再将这个临时变量给d。

而自定义类型也一样，其实是先将1给A类型的临时变量，这个临时变量会调用构造函数用1初始化，然后用拷贝构造函数将临时变量给aa2。这样说来我们应该是调用了构造+拷贝构造我们验证一下：

如何确定确实有一个临时变量呢？

 我们通过传引用发现会报错初始值必须为不可修改的左值，然后我们加个const试一下：

我们之前说过临时变量具有常性必须加const，在这里我们普通变量会报错而加了const就能正常这就说明了在类型转换期间一定是有临时变量的。 

class A
{
public:
	A(int a)
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& d)
	{
		cout << "A(const A& d)" << endl;
		_a2 = d._a2;
		_a1 = d._a1;
	}

private:
	int _a2;
	int _a1;
};
int main() {
	//A aa(1);
	A aa2 = 1;
	
}

这里为什么只调用了一个构造函数呢？其实这里就是编译器的优化了， 编译器直接优化为用1去构造aa2。也就是说实际过程变成了：构造+拷贝构造+编译器优化-->构造。那如果我们不想让编译器优化有什么办法呢？这里c++引入了explicit关键字，将关键字加到构造函数前面编译器就不能进行类型转换了。如下图：

上面是单参数的构造函数，那如果是多参数的构造函数呢？

  如上图所示， 多参数的构造函数也支持只不过需要加大括号，在这里要说明一下，单参数的隐式类型转换是c++98就支持的，而多参数的隐式类型转换是c++11支持的。同样我们在前面加一个explicit就不支持了。

同样编译器还会对函数传参进行优化：

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
void func1(A aa)
{}

int main()
{
	A aa1;
	func1(aa1);  //
	func1(2);   //构造 + 拷贝构造 + 优化 -> 构造
	func1(A(3));  //构造 + 拷贝构造 + 优化 ->构造
	return 0;
}

通过调试我们发现，func1(2)本来应该是构造+拷贝构造，结果被优化成了构造。func(A(3))也一样，A（3）是一个匿名对象，然后将A（3）拷贝给aa，然后优化为构造。

 那么如果函数参数变成传引用还会优化吗？

 首先Func2的参数前面必须const，否则连编译都不会通过，因为Func2(2)中2是一个常量。其次我们可以看到当传引用的时候编译器是不会优化的，因为传引用本身就是将自身传过去，没有什么再减少空间开辟的优化了。再看下一个：

这里func3的顺序大家应该都清楚，进入函数后aa先构造，然后值返回会调用拷贝构造，函数要结束时aa调用析构，那么A aa1 = func3()的过程是什么样呢？这个过程按照我们所学的知识来理解应该是构造，拷贝构造，然后再拷贝构造赋值给aa1所以应该是1个构造2个拷贝构造。那么我们验证一下：

 我们发现只有1个构造1个拷贝构造，其实这里是被编译器优化了。

 当我们直接返回匿名对象的时候发现本来应该构造+拷贝构造直接变成了构造。再看下图：

这个我们发现更神奇了，本来应该是构造+拷贝构造+拷贝构造直接被优化为1个构造，编译器直接用匿名对象初始化aa1了。所以我们得出一个结论：能用匿名对象直接返回的就用匿名对象这样会加速编译器的优化。 

编译器优化总结：

1.对象返回

接收返回值对象，尽量拷贝构造方式接收，不要赋值接收。

函数中返回对象时，尽量返回匿名对象。

2.函数传参总结

尽量使用const & 传参

二、static成员

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

我们先用以前的知识实现一个类，这个类可以计算出创建了多少个对象。

int count = 0;
class Test
{
public:
	Test()
	{
		count++;
	}
};
int main()
{
	Test t1;
	cout << count << endl;
	return 0;
}

 按照我们以前的写法我们发现是无法正常编译的，我们看一下报错信息：

这是因为我们定义的全局变量的名称与库中的某个函数名冲突了，如果是以前我们直接修改变量名称即可，但我们既然学了c++就用c++的方式解决，我们知道c++的类中定义的变量名称是不会与库中的名称冲突的，那我们如何既能将变量写到类中又能让这个变量不属于这个单独的类属于所有的类对象呢？这里就用到了static修饰的变量。如下图：

class Test
{
public:
	Test()
	{
		count++;
	}
	static int count;
};
int Test::count = 0;
int main()
{
	Test t1;
	cout << t1.count << endl;
	return 0;
}

static修饰的变量或函数不属于某个对象，属于所有对象，属于整个类。静态成员变量必须在类外进行初始化，类中仅仅是声明。 

 我们再多加几个变量

 这样还不算成功的计算出所有创建对象的数量，看下图：

当我们调用拷贝构造创建一个新的对象的时候发现数量不对了，我们应该要加上拷贝出来的对象的数量，所以我们改进一下：

 这样即使我们利用拷贝构造创建新对象也会成功加上数量。

那如果定义的count是私有的该怎么办呢？

私有的很明显是不能直接访问的，所以我们利用函数去返回。

 但是如果我们没有创建对象呢？我们不能因为调用一个函数再去创建一个类对象吧，这时候就该静态函数出场了。

class Test
{
public:
	Test()
	{
		count++;
	}
	Test(const Test& d)
	{
		count++;
	}
	static int GetCount()
	{
		return count;
	}
private:
	static int count;
};
int Test::count = 0;
int main()
{
	cout << Test::GetCount() << endl;
	return 0;
}

 静态函数可以直接用类名访问，并且静态函数内不可以访问普通成员变量。如下图：

静态成员特性：

1.静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。

2.静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。

3.类静态成员即可用类名：：静态成员或者对象.静态成员来访问。

4.静态成员函数没有隐藏的this指针，不能访问任何非静态成员.

5.静态成员也是类的成员，受public，protected, private访问限定符的限制。

 匿名对象到下一行直接就调用析构函数了所以声明周期只在这一行。

那么匿名对象有什么作用呢？

比如我们需要一个值用来初始化一个对象，然后利用函数返回一个初始化的匿名对象即可。

三丶友元

友元其实我们之前已经接触过了，在运算符重载的时候我们需要重载<<符号用到了友元，友元提供了一种突破封装的方式，有时提供了便利。但是友元增加了耦合度，会破坏封装，所以友元不宜多用。

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

这是我们之前的例子：

class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, 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;
};
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;
 cin >> d;
 cout << d << endl;
 return 0;
}

说明：

1.友元函数可访问类的私有和保护成员，但不是类的成员函数。

2.友元函数不能用const修饰。

3.友元函数可以在类定义的任何地方声明，不受类访问限定符的限制。

4.一个函数可以是多个类的友元函数。

5.友元函数的调用和普通函数的调用原理相同 

友元类：

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)
   {
       // 直接访问时间类私有的成员变量
       _t._hour = hour;
       _t._minute = minute;
       _t._second = second;
   }
private:
   int _year;
   int _month;
   int _day;
   Time _t;
};

四丶内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员，外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的所有成员，但是外部类不是内部类的友元。

特性：

内部类可以定义在外部类的public，protected，private都是可以的。

注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名

sizeof（外部类）=内部类，和内部类没有任何关系

 通过上图我们可以发现，A类的大小是4字节也就是int h的大小，如果包含类B的大小应该是8字节才对，所以sizeof（外部类）与内部类无关。

受类域限制是什么意思呢？看下图：

B对象是无法直接定义的，需要加上域作用限定符。

 当然这是类B公有的情况，如果类B是私有呢？

我们发现当类B是私有的时候是无法直接用类B创建对象的，这就证明内部类受外部类的类域限制。

class A
{
private:
	int h;
	int k;
public:
	class B
	{
	public:
		void Print(A& a)
		{
			cout << a.h << endl;
			a.k = 10;
		}
	private:
		int b;
	};
};
int main()
{
	A aa;
	A::B bb;
	return 0;
}

 从上图可以发现内部类是外部类的友元类，我们在内部类B中直接访问了A类中的h和k变量。

总结