C++：类的六个默认成员函数

---

个人主页 ： 个人主页
个人专栏 ： 《数据结构》 《C语言》《C++》

前言

本篇博客作为C++知识总结，我们来认识类的六个默认成员函数。

下面我主要以日期类作为示例显示。

---

一、构造函数

概念

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

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造函数，但是构造函数的主要任务并不是开辟空间创建对象，而是初始化对象。

#include 

using namespace std;

class Date
{
public:
	//构造函数 函数名与类相同 无返回值 
	Date()
	{
		// 提示：已调用构造函数
		cout << "Date()" << endl;

		_year = 0;
		_month = 0;
		_day = 0;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d;
	d.Print();

	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

结果如下：

构造函数在创建类类型对象时由编译器自动调用。

特性

• 1.函数名与类相同
• 2.无返回值
• 3.对象实例化时编译器自动调用对应的默认构造函数
• 4.无参的构造函数，全缺省的构造函数，编译器默认生成的构造函数都是默认构造函数(只能有一个)
• 5.如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数(内置类型不处理，自定义类型调用对应的默认构造函数)，当用户显示定义构造函数，编译器将不再生成。
• 6.构造函数可以重载
• 7.在C++11中，内置类型成员变量在类中的声明可以给默认值(我们有初始化列表可以替换)

示例：

class Date
{
public:
	//构造函数 函数名与类相同 无返回值 
	// 默认构造函数
	//Date()
	//{
	//	// 提示：已调用构造函数
	//	cout << "Date()" << endl;

	//	_year = 0;
	//	_month = 0;
	//	_day = 0;
	//}

	// 默认构造函数
	/*Date(int year = 0, int month = 0, int day = 0)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/

	// 非默认构造函数
	/*Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d;
	d.Print();

	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

---

:特性4：

---

特性3：

---

注意：

• 如果使用无参的构造函数创建对象时，对象后不用跟() [函数调用] ，否则编译器会识别为函数声明。
• 如果使用全缺省的构造函数创建对象不传参时，对象后不用跟() [函数调用] ，否则编译器会识别为函数声明。

二、析构函数

概念

析构函数 ： 与构造函数功能相反，析构函数不是完成完成对象本身的销毁，局部对象的销毁工作是由编译器完成的，而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作(也就是说主要对于动态申请的资源进行销毁)

class Date
{
public:
	 
	Date(int year = 0, int month = 0, int day = 0)
	{
		cout << "Date(int year = 0, int month = 0, int day = 0)" << endl;

		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	// 析构函数
	~Date()
	{
		cout << "~Date()" << endl;

		_year = 0;
		_month = 0;
		_day = 0;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d(2023, 9, 12);
	d.Print();

	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

---

特性

• 析构函数名在类前加上字符 ~
• 无参数无返回类型
• 一个类只能有一个析构函数，若未显示定义，系统会自动生成默认的析构函数
• 对象生命周期结束时，C++编译器会自动调用析构函数
• 对于内置类型，析构函数不做处理。对于内置类型，析构函数会调用对应的析构函数
• 如果类中没有申请资源时，析构函数可以不写(如示例中的日期类)，直接使用编译器生成的默认析构函数，但有资源申请时，一定要写析构函数(所有的指针类型都是内置类型，编译器生成的析构函数并不会清理指针指向的空间)，否则会造成资源泄漏。

那么编译器生成的析构函数有什么用？

class A
{
public:
	A(int a = 0)
	{
		cout << "A(int a = 0)" << endl;
		_a = a;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

class Date
{
private:
	// 内置类型
	int _year = 1;
	int _month;
	int _day;

	// 自定义类型
	A _aa;
};

int main()
{
	Date d;

	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

如上所示，编译器自动生成的析构函数处理自定义类型时可以自动调用对应的析构函数，那么对于
嵌套的数据结构(如两个栈模拟队列)而言，我们就不需要为该结构写对应的析构函数，直接使用编译器默认生成的即可

三、拷贝构造函数

概念

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

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

	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl;

		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void func(Date d1)
{
	cout << "void func(Date d1)" << endl;
}

int main()
{
	Date d(2023,9,11);
	func(d);

	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

---

特性

• 拷贝构造函数是构造函数的一个重载形式

---

• 拷贝构造函数的参数只有一个且必须是类类对象的引用，如果不为引用，而使用传值方式时编译器会直接报错，因为这会引发无穷递归

当我们不进行引用传参时，为什么会发生无穷递归？

首先我们要知道拷贝构造函数的三个调用场景

• 使用以存在对象创建新对象
• 函数参数类型为类类型对象(创建形参)
• 函数返回值为类类型对象(会创建临时对象保存函数返回值)

所以当拷贝构造函数的参数不是引用类型时：

---

• 若未显示定义拷贝构造，编译器会生成默认的拷贝构造函数，默认的拷贝构造函数对对象按内存存储按字节序完成拷贝(浅拷贝)
• 编译器默认生成的拷贝构造函数，对于内置类型和自定义类型都是浅拷贝

对于日期类这样没有资源申请的类，用编译器自动生成的拷贝构造即可。
对于有资源申请的类(栈，队列，顺序表…)，必须完成深拷贝，不能用浅拷贝

如下：
使用编译器自动生成的拷贝构造

这就是因为对象a1是对象a的浅拷贝，使对象a. _ date 与 对象a1. _ date指向同一个动态申请的空间，而对象a1析构时会释放该空间，对象a析构时会再次释放该空间就会导致错误。
正确写法应该完成深拷贝，使对象a1另申请一块空间在复制对象a指向空间的内容

---

四、赋值运算符重载

运算符重载

C++为了增强可读性引入了运算符重载，运算符重载是具有特殊函数名的函数
函数名为：关键字operator后面加需要重载的运算符符号
函数原型：返回值类型 operator操作符(参数列表)
如下：对日期类 小于符号( < )重载

class Date
{
public:
	Date(int year = 0, int month = 0, int day = 0)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 返回值类型  operator操作符  参数
	bool operator<(const Date& d)
	{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year && _month < d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day < d._day)
		{
			return true;
		}

		return false;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 9, 12);
	Date d2(2022, 9, 12);

	cout << (d1 < d2) << endl;
	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

---

注意：

• 不能通过链接其它符号来创建新的操作符
• 重载操作符参数中必须有一个类类型
• 用于内置类型的运算符，其含义不能改变
• 作为类成员函数重载时，其形参看起来比操作数数目少一个(隐藏了一个this指针)
• ( .* / :: / sizeof / ? : / . )这5个操作符不能重载
• 对于前置++运算符重载，如日期类( Date& operator++() )
• 对于后置++运算符重载，如日期类( Date& operator++( int ) )

---

赋值运算符重载

赋值运算符重载格式：

• 参数类型：const T&，传递引用可以提高传参效率
• 返回值类型：T&，返回引用可以提高返回效率，有返回值目的是为了支持连续赋值
• 检测是否自己给自己赋值
• 返回*this：要复合连续赋值的含义

---

注意：

• 赋值运算符只能重载为类的成员函数不能重载为全局函数

因为：赋值运算符如果不在类中显示定义实现，编译器会自动生成一个默认的函数。此时与用户在类外定义实现的赋值运算符重载函数(要使用友元函数或将成员变量变成公有)冲突，故赋值运算符重载只能是类的成员函数。

---

• 编译器生成的赋值运算符重载，在对于内置类型与自定义类型都是以值的方式逐字节拷贝。(内置类型直接复制，自定义类型成员变量需要调用对应的赋值运算符重载完成赋值)

与拷贝构造类似，对于有资源申请的类型，要实现深拷贝取完成赋值运算符重载。

编译器默认生成

自我实现的

---

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

const成员

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

注意：

• 被const修饰的对象只能调用const成员函数，不能调用未被调用const函数修饰的成员函数
• 为被const修饰的对象，可以调用正常的成员函数，也可以调用const成员函数
• 如果有成员函数重载为const成员函数，那么编译器在调用该函数时会进行最优匹配
  

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

这两个默认成员函数一般不用自己完成，使用编译器默认生成的即可。
但如果，你不想让他人获取对象的地址，或让他人获取指定的地址时，就可以自我实现这两个函数。

class A
{
public:
	A* operator&()
	{
		return this;
	}

	const A* operator&() const
	{
		return this;
	}
private:
	int _a;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

总结

以上就是我对于类的六个默认成员函数的总结。感谢支持！！！