C++中类和对象的分析与品鉴（下篇）

类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数，下面我们来分析分析。

1、构造函数

概念：
在我们前面学习数据结构的时候，用C语言来实现栈或队列等情况下，我们自定义的类型都要进行初始化，如果没有初始化，程序可能就会运行崩溃；所以我们要专门来写一个初始化函数。但是在C++中有没有类似于初始化函数的存在呢，那当然就是构造函数了。
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

相关特性：
构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
① 函数名与类名相同。
② 无返回值。
③ 对象实例化时编译器自动调用对应的构造函数。
④ 构造函数可以重载
⑤ 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
⑥ 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器自动生成的构造函数，都可以认为是默认成员函数。
⑦ 构造函数对内置类型和自定义类型的处理情况（详情如下）。

重点注意：
第④点的注意事项：
下面两个构造函数可以重载

class Date
{
public:
	// 1.无参构造函数
	Date()
	{}
	// 2.带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//上面两个函数构成重载
private:
	int _year;
	int _month;
	int _day;
};

下面两个构造函数语法上虽然可以构成重载，但是定义d1的时候就不知道调用哪一个构造函数，会造成二义性，从而运行报错。

class Date
{
public:
	Date()
	{
		_year = 2022;
		_month = 1;
		_day = 1;
	}
	Date(int year = 2022, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1;
	//运行失败
}

第⑦点的详细分析：

2、析构函数

概念：
同样的道理，在以前用C语言实现链表和栈的时候，最后一定要释放在堆上开辟的内存；如果忘记释放就会造成内存泄漏。而在C++中也有一个函数和内存释放函数类似，那就是析构函数。

析构函数： 与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

相关特性：
析构函数是特殊的成员函数。
其特征如下：
① 析构函数名是在类名前加上字符 ~。
② 无参数无返回值。
③ 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
④ 对象生命周期结束时，C++编译系统系统自动调用析构函数
⑤关于编译器自动生成的析构函数；如果我们不写默认生成析构函数，对于内置类型不做处理， 对于自定义类型回去调用它的析构函数

3、拷贝构造函数

概念：
拷贝构造函数： 只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

相关特性：
① 拷贝构造函数是构造函数的一个重载形式。
② 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。分析如下：

③ 若未显示定义，系统生成默认的拷贝构造函数

4、赋值运算符重载

运算符重载

我们知道在C语言当中，自定义类型是不支持自定义类型对象使用运算符；
C++默认情况中是不支持自定义类型对象使用运算符，但是有了运算符重载，自定义类型就能使用运算符了。
并且C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为： 关键字operator后面接需要重载的运算符符号。
函数原型： 返回值类型 operator操作符(参数列表)
注意特性：
① 不能通过连接其他符号来创建新的操作符：比如operator#
② 重载操作符必须有一个类类型或者枚举类型的操作数
③ 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
④   .*   ::  sizeof  ?:  .   注意以上5个运算符不能重载
⑤ 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参。（举例如下：）

class Date
{
public:
	Date(int year = 2022, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// bool operator==(Date* this, const Date& d2)
	// 这里需要注意的是，左操作数是this指向的调用函数的对象
	// 作为类成员的重载函数时，
	// 其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，
	// 限定为第一个形参
	bool operator==(const Date& d2)
	{
		return _year == d2._year
		&& _month == d2._month
			&& _day == d2._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Test()
{
	Date d1(2018, 9, 26);
	Date d2(2018, 9, 27);
	cout << (d1 == d2) << endl;
}

赋值运算符 (=) 重载

下面我们还是以日期类来看看赋值运算符重载是怎么搞的吧，代码如下：

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

	//赋值运算符重载
	Date& operator=(const Date& d)
	{
		// 极端情况下自己给自己赋值就可以不同处理了，直接判断一下跳过
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

赋值运算符重载有以下特性：
① 参数和返回值都是引用类型
② 要检测是否自己给自己赋值
③ 返回值为*this
④ 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，
对于内置类型成员，会完成字节序拷贝（浅拷贝）
对于自定义类型成员，会调用它的 operator=

注意事项：
要区分开来什么是拷贝构造，什么是赋值运算符重载，并不是有了等号(=)就是赋值运算符重载。
拷贝构造： 一个已经存在的对象拷贝初始化一个马上创建实例化的对象。
赋值运算符重载： 两个已经存在的对象之间进行赋值拷贝。
举例如下：还是以上面的日期类为例子

int main()
{
	Date d1(2022, 2, 16);
	Date d2(2022, 3, 31);
	Date d3(2022, 9, 26);

	// 一个已经存在的对象拷贝初始化一个马上创建实例化的对象
	Date d4(d1);  // 拷贝构造
	Date d5 = d1; // 拷贝构造

	// 两个已经存在的对象之间进行赋值拷贝
	d2 = d1 = d3;  //赋值运算符重载   d1.operator=(d3)
	//d1 = d3;    //赋值运算符重载    d1.operator=(d3)
	return 0;
}

5、取地址及const取地址操作符重载

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

这两个默认成员函数我们一般不用自己写，用默认生成的就足够了。

6、const成员函数

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

有了const对象和const成员函数之后就有了以下特性：
1、 const对象不可以调用非const成员函数
2、 非const对象可以调用const成员函数
3、 const成员函数内不可以调用其它的非const成员函数
4.、非const成员函数内可以调用其它的const成员函数

我们再来补充一下关于权限的问题：什么时候才是权限的放大或缩小呢？

int main()
{
	int a = 20;
	const int x = a;
	//这样就不是权限的放大或缩小，
	//因为赋值对a本身没有影响，只是把a拷贝给x而已
	return 0;
}

int main()
{
	//int a = 20;
	//const int x = a;
	//这样就不是权限的放大或缩小，
	//因为赋值对a本身没有影响，只是把a拷贝给x而已


	//下面才涉及权限的放大或缩小
	int* a;
	const int* b;

	b = a; //把a给b可以，这样a的权限就缩小了，a指向的内容就不能再被改变了

	a = b; //把b给a不可以，
	//因为这样权限就放大了，权限只能缩小而不能放大

	return 0;
}

7、构造函数的再次理解

初始化列表

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

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

虽然上面的构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
所以类对象在什么适合进行的初始化呢？我们就要先学习初始化列表。

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

class Date
{
public:
	//用初始化列表的方式进行初始化
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

问题来了，有人会问在构造函数里面赋值不就可以了吗？为什么还要引出初始化列表呢？
我们要清楚，在C++中有很多类型的，对于int型不写初始化列表，定义的时候不赋值，在构造函数里面再赋值是当然可以的。但是对于const、引用、没有默认构造函数的自定义类型成员变量必须要在定义的时候进行初始化，所以初始化列表是一定要有的。

下面我们我们以两个初始化例子的对比来加深初始化列表的理解：
不用初始化列表进行初始化：

程序运行结果为：

用初始化列表进行初始化：

程序运行结果为：

两种初始化方式的对比分析：

所以初始化列表有以下特性：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
   引用成员变量
   const成员变量
   默认构造函数的自定义类型成员
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。（重点注意）

关于第4点我们还是用一道题来分析分析：

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 1
B.程序崩溃
C.编译不通过
D.输出1 随机值

这道题就是运用到了上面特性的第4点，因为成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关；所以 _a2先被初始化，为随机值，然后再初始化 _a1；这样结果就是D选项。

explicit关键字

我们在学习C语言的时候学过隐式类型转换和强制类型转换，比如：

	// 隐式类型转换 - 相近类型 -- 表示意义相似的类型
	double d = 1.6;
	int i = d;
	const int& i = d;

	// 强制类型转换 - 无关类型
	int* p = &i;
	int i = (int)p;

而在C++中构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。例子如下：

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

    //如果用explicit修饰构造函数，将会禁止单参构造函数的隐式转换
	//explicit Date(int year)
	//{}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022);
	Date d2 = 2023;  //隐式类型转换
}

// 虽然他们两都是直接构造，但是过程是不一样的
Date d1(2022);
Date d2 = 2023; // 隐式类型转换
// 本来用2022构造一个临时对象Date(2022)，再用这个对象拷贝构造d2
// 但是C++编译器在连续的一个过程中，多个构造会被优化，合二为一。
// 所以这里被优化为直接就是一个构造

8、static成员

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

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

关于static成员的应用： 如何实现一个类，计算中程序中创建出了多少个类对象？
我们知道创建一个类对象的时候一定会调用构造函数或者拷贝构造函数，所以我们只要知道调用了多少次构造函数或者拷贝构造函数就可以了。实现如下：

class F
{
public:
    //构造函数
	F(int a=0)
	{
		_a = a;
		_count++;
	}
	//拷贝构造函数
	F(const F& aa)
	{
		_a = aa._a;
		_count++;
	}

	// 没有this指针，只能访问静态成员变量和成员函数
	static int GetCount()
	{
		return _count;
	}
private:
	int _a;
	static int _count; //声明
};

int F::_count = 0;  // 定义初始化

int main()
{
	F f1;
	F f2;
	F f3(f1);
	//调用接口即可知道创建了多少个类对象
	cout << F::GetCount() << endl;
}

9、C++11的成员初始化新方法

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。
这里缺省值的作用： 在初始化列表阶段，没有对成员变量初始化，它就会使用缺省值初始化。（举例如下）

class A
{
public:
	// 如果你再初始化列表阶段，没有对成员变量初始化，它就会使用缺省值初始化
	A()
	{}
private:           // 要注意的是这里不是初始化，因为这里是声明，不能初始化
	int _a1 = 0;   // 这个里是给成员变量缺省值
	int* p = (int*)malloc(6*20);

	int arr[10] = { 1, 2, 3, 4, 5 };

	// 静态的不能这样给缺省值，因为构造函数对静态成员不作处理
	// 必须在类外面全局位置定义初始化
	// static int _sCount = 0;
	static int _count;
};

//静态成员应该这样初始化
int A::_count = 0;

int main()
{
	A aa;

	return 0;
}

10、友元

友元函数

我们直接来看要使用友元函数的情况：怎么去重载流插入运算符operator<< ？
我们知道没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是
实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员。使用我们要使用友元函数才能在类外面访问成员。（举例如下）

class Date
{
	//友元函数的声明
	friend ostream& operator<<(ostream& _cout, const Date& d);
public:
	Date(int year=0, int month=0, int day=0)
		: _year(year)
		,_month(month)
		,_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

//流插入的重载定义，因为是友元函数可以访问类内部的成员
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << d._month << d._day;
	return out;
}

int main()
{
	Date d;
	cout << d << endl;
	return 0;
}

友元函数的特性如下：

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

友元类

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

class A
{
	// 声明B为A类的友元类，则在B类中就直接访问A类中的私有成员变量
	friend class B;
private:
	int a;
	int b;
	int c;
};

class B
{
public:
	void SetB(int x,int y,int z)
	{
		// 直接访问A类私有的成员变量
		_aa.a = x;
		_aa.b = y;
		_aa.c = z;
	}
private:
	int _e;
	int _f;
	int _g;
	A _aa;
};

11、内部类

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

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

特性：

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

//例子如下：
class A
{
private:
	static int k;
	int h;
public:
	// B为内部类
	// 1、内部类B和在全局定义是基本一样的，
	//只是他的受外部类A类域限制,定义在A的类域中
	// 2、内部类B天生就是外部类A的友元，
	//也就是B中可以访问A的私有，A不能访问B的私有
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << a.k << endl; //可以
			cout << a.h << endl; //可以
		}
	private:
		int _b;
	};

	void f(B bb)
	{
		// A不是B的友元，不能访问B
		bb._b;
	}
};