类的六个默认成员函数

C++中每一个类都有6个默认的成员函数，这六个成员函数都是编译器自动生成的，用户一旦提供了，编译器将不再自动生成

一、构造函数

概念

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

特征

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载
5. 如果用户不显示定义构造函数，编译器会默认生成一个默认的无参的构造函数，用户定义以后，编译器将不再生成。

• 默认构造函数的意义 ：
  对于一个类的成员函数中有另一个类的成员变量时，编译器生成的默认构造函数会自动调用该自定义类类的构造函数，如：Date类成员中包含一个Time类，调用时间类的构造函数在Date的默认构造函数中实现。定义一个Date类对象是并不会调用日期
  

使用

对于日期类，自己定义一个构造函数：

Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
1
2
3
4
5
6

自己定义构造函数后，便可以通过下面的方式定义并初始化对象，不用再调用 Init() 函数：

Date d(2022, 3, 5);
1

此时如果定义对象不给参数，便会报错，因为定义的构造函数是由参数的：

解决方法是

• 第一种：再写一个无参的构造函数，构造函数支持重载
  
• 第二种：全缺省的的构造函数，这种语法C++11支持，98不支持
  

注意：无参构造函数和全缺省的构造函数都称为默认的构造函数，但是二者不能共存

二、析构函数

概念

析构函数：与构造函数功能相反，写法时在类名前加一个取反符号"~"，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。如堆上申请的内存空间，文件指针，套接字等。
注意：如果类对象中没有资源的管理，析构函数可以不自己自定义

特征

1. 没有返回值类型，没有参数，不能重载
2. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
3. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

自定义日期类和时间类的析构函数

//日期类的析构函数
~Date()
	{
		cout << "~Date" << endl;
	}
1
2
3
4
5

~Time()
	{
		cout << "~Time" << endl;
	}
1
2
3
4

与构造函数相同，如果成员变量中有自定义类，当对象销毁时，编译器会自动调用该自定义类的析构函数，这也是编译器默认生成的析构函数的一种作用。

调用构造函数和析构函数的顺序

定义两个类A和B验证调用构造函数和析构函数的顺序

class A

class A
{
public:
	A()
	{
		cout << "A" << endl;
	}

	~A()
	{
		cout << "~A" << endl;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13

class B

class B
{
public:
	B()
	{
		cout << "B" << endl;
	}
	~B()
	{
		cout << "~B" << endl;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12

调用Test函数，验证构造与析构的先后顺序：

通过结果我们可以得出结论：先构造的后析构，后构造的先析构

三、拷贝构造函数

概念

只有单个形参，该形参是对本类类型对象的引用，一般用const修饰，在用已存在的类类型对象创建新的类类型对象时使用。

特征

1.构造函数的一种重载

拷贝构造函数与构造函数名一样，与类名相同，区别就是拷贝构造函数的参数是类类型对象的引用，符合重载的要求：作用域相同，函数名相同，形参列表不同

2.传参方式——类类型对象的引用传参

• 拷贝构造函数的参数要使用类类型对象的引用，是语法要求，如图：
  
• 另一方面，我们也可以对函数调用关系进行分析
  
  一句话总结就是，传值传参的方式在传参的时候会引发值拷贝，而引起无限递归。而如果是引用传参，形参是实参的别名，则不会有上述问题。

3.默认生成

用户未显式定义，编译器会生成默认的拷贝构造函数。这种默认的拷贝构造函数是一种浅拷贝，即按内存中的字节序进行拷贝，内存中放什么就靠什么数据。
如图，对于日期类，系统默认生成的拷贝构造函数：

4.浅拷贝

编译器会自动生成默认的拷贝构造函数，但是默认的拷贝构造函数是浅拷贝的方式，存在一些问题。
对于这样一个string类：

class String
{
public:
	String(const char* str = "jack")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~String()
	{
		cout << "~String()" << endl;
		free(_str);
	}
private:
	char* _str;
};


void Test()
{
	String s1("hello");//调用构造函数
	String s2(s1);//调用默认的拷贝构造函数
}

int main()
{
	Test();
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

调试过程中，析构第二个对象时程序发生崩溃：

程序崩溃的原因是：浅拷贝两个对象共用的是同一份内存资源，析构时同一块内存被释放两次。

5.调用场景

• 使用已经存在的对象创建新对象，如：Date d2(d1)
• 数参数位类类型对象：函数参数位类类型对象时要发生实参到形参的值拷贝，会调用拷贝构造函数
• 函数返回值位类类型对象

代码演示

class Date
{
public:

	//构造函数
	Date(int year = 2022, int month = 7, int day = 30)
	{
		_year = year;
		_month = month;
		_day = day;
		cout << "Date()" <<this<< endl;
	}
	//拷贝构造
	Date(const Date& d)
	{
		_year = d._year;
		_day = d._day;
		_month = d._month;
		cout << "Date(const Date&):" <<this<< endl;
	}
	//析构
	~Date()
	{
		cout << "~Date():" <<this<< endl;
	}
private:
	int _year;
	int _month;
	int _day;
	//Time t;
};

Date TestDate(Date param)
{
	return param;
}

void Test()
{
	Date d1;
	Date d2(d1);
	TestDate(d1);
}
int main()
{
	Test();
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

定义日期类，定义一个返回值和参数都为Date类型的函数，查看其调用拷贝构造函数的情况：

四、赋值运算符重载

操作符重载的概念

看赋值运算符重载之前，先要知道什么是运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，有返回值类型及形参列表，返回值类型和形参列表与普通函数相同。
函数名：operator后跟要重载的运算符符号
函数原型：返回值类型 operator操作符(参数列表)

注意事项：

1. 只能重载运算符，不能重载其他符号
2. 重载操作符必须有一个类类型或者枚举类型的操作数
3. 不能改变符号原有的含义
4. 作为类成员的重载函数，形参数目少一个，因为类成员函数有隐藏的this指针，是成员函数第一个形参，如图：
   
5. sizeof 、.* 、:: 、?: 、. 注意以上5个运算符不能重载

赋值运算符重载

自定义赋值运算符的重载

Date& operator=(const Date& d)
	{
		//判断是否给自己赋值
		if (&d != this)
		{
			//相当于用d对象给*this赋值
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;//连续赋值
	}
1
2
3
4
5
6
7
8
9
10
11
12

重载之后便可以使用 “=”，用一个日期类对象给另一个对象赋值：

注意事项：

• 必须重载成成员函数，因为如果写到类外，编译器还会为类生成一个给默认的赋值运算符重载函数
• 参数为类类型对象的引用
• 返回值为类类型对象的引用，且必须返回返回*this，因为连续赋值时，后面“=”的返回值会作为前面“=”的参数。

默认生成赋值运算符重载函数

编译器会默认生成赋值运算符重载函数，如图：

对于日期类这样没有资源管理的类，可以使用编译器默认的重载函数，但是如果类中有资源管理，需要自己重载，因为编译器生成的赋值运算符重载采用的是浅拷贝的方式。

仍以string类为例：

class String
{
public:
	String(const char* str = "")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~String()
	{
		cout << "~String()" << endl;
		free(_str);
	}
private:
	char* _str;
};
void TestString()
{
	String s1("hello");
	String s2("world");
	s1 = s2;//调用默认的赋值运算符重载函数
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

程序崩溃：

程序在第二次调用析构析构函数时崩溃，因为两个string对象使用的时同一块内存空间，第一次析构已经释放过这块内存。
对于内部涉及到资源管理的类，使用默认的赋值运算符重载函数会有两个问题：

1. 析构时重复释放内存
2. 被赋值的对象之前开辟的空间无法找到，发生内存泄漏

其他运算符重载重载：日期类运算符重载

五、&及const&重载

const成员函数

概念

const修饰的类成员函数称为const成员函数，const修饰成员函数，实际修饰的是该成员函数隐藏的this指针，表明在该成员函数中不能对类的成员变量进行修改。

• 以日期类为例，this指针原本的类型是：Date * const this，其指向不可修改
• const修饰的成员函数中，this指针的类型是：const Date *const this，表示this的指向和this指向的内容（即该类对象的成员函数变量）不可修改。
  
• mutable修饰的成员变量可以在const成员函数中被修改

四个问题

1. const对象可以调用非const成员函数吗？
   不能，因为const对象不能被修改，而非const成员函数内部可能会修改对象的的成员变量。
2. 非const对象可以调用const成员函数吗？
   可以，因为const成员函数内部不会修改成员变量，而非const成员对象无论修改不修改都不会有错误。
3. const成员函数内可以调用其它的非const成员函数吗？
   不能，因为其他非const成员函数内部可能会修改成员变量，不符合const成员函数的要求。
4. 非const成员函数内可以调用其它的const成员函数吗？
   可以，因为非const成员函数内部可以修改成员变量，而调用其它的const成员函数不会修改成员变量。

&及const&重载

对取地址符和const的重载

Date* operator&()
	{
		return this;
	}

	const Date* operator&()const
	{
		return this;
	}
1
2
3
4
5
6
7
8
9

这里const&的重载，因为后面的const修饰的是this指针，所以返回值也是const Date* 类型。
这两个运算符的重载编译器也会默认生成，一般使用默认的即可。