详细c++必修：类和对象(二)

一类的默认成员函数

默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我 们不写的情况下编译器会默认⽣成以下6个默认成员函数

其中前四个用的比较频繁，我们一定要做到熟练使用。

C++11以后还会增加两个默认成员函数，移动构造和移动赋值。我们不做讲解。

1构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并 不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化 对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数⾃动调⽤的 特点就完美的替代的了Init。

例如

第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

编译器在定义类的时候会自动调用他们的构造函数和析构函数（不像以前写栈的时候我们要自己在主函数中写Inite 和destroy函数）。我们在构造函数中加一句打印来验证（实际操作不用）。

默认构造函数

默认构造函数有三种

下面是常见的三种构造函数情况

1.无参

Date()//无参

{

	_year = 2004;
	_month = 2;
	_day = 12;
	cout << _year << " " << _month << " " << _day << endl;
}

2全缺省

Date(int year = 2003, int month = 12, int day = 23)
//全缺省
{

	_year = year;
	_month = month;
	_day = day;
	cout << _year << " " << _month << " " << _day << endl;
}

3不写自动生成

其中不写自动生成的看编译器，有可能初始化为0，也有能是随机值（上图编译环境是vs2022，是随机值）

⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函 数。但是这三个函数有且只有⼀个存在，不能同时存在。

构造函数的特点：

1. 函数名与类名相同。
2. ⽆返回值。 (返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
3. 对象实例化时系统会⾃动调⽤对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显 式定义编译器将不再⽣成。 比特就业课
6. ⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函 数。但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成 函数重载，但是调⽤时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认⽣成那个叫 默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调 ⽤的构造就叫默认构造。
7. 我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始 化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始 化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤ 初始化列表才能解决，初始化列表以后再讲

2析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的， 函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对 象中资源的清理释放⼯作。析构函数的功能类⽐我们之前Stack实现的Destroy功能，⽽像Date没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

也就是说我们是否写析构取决于是否有资源的释放，如指针和文件。（上面Date类中全是内置类型，没有指向空间，故不写）。

写析构函数的情况

那么我们什么时候要写析构函数，什么时候不用写？ 举个例子

如图下面Stack类中有指针的指向所以要写析构释放资源。

#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
	// 显⽰写析构，也会⾃动调⽤Stack的析构
/*~MyQueue()
{}*/
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st;
	MyQueue mq;
	return 0;
}

上面是我们在c++中实现栈的代码，然后定义了一个队列类。我们在主函数中调用。其中Stack类中有指针指向的空间，所以必须写析构，但是MyQueue类中却不用写。

这是为什么？ 因为编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构。 MyQueue自己并没有指向空间，而内部的Stack会调用自己的析构。所以不用写。

1. 析构函数名是在类名前加上字符 ~。
2. ⽆参数⽆返回值。 (这⾥跟构造类似，也不需要加void)
3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成>默认的析构函数。
4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数。
5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置>类型成员不做处理，⾃定类型成员会 调⽤他的析构函数。
6. 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类 型成员⽆论什么情况都会⾃动调⽤析构函数。
7. 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如 果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时，⼀定要 ⾃⼰写析构，否则会造成资源泄漏，如Stack

1. ⼀个局部域的多个对象，C++规定后定义的先析构。

调试过程中后定义的MyQueue先被析构。然后Stack再被析构。

3拷贝构造函数

如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数 也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。

严格意义上来说拷⻉构造函数是构造函数的一个重载。 所以写法和构造函数一样只是参数不同，它也可以自动生成，但有时候也需要自己写。

它默认为下面形式

Date(const Date& d)

我们为什么传参时要采用&d的形式呢？

下面我们来了解几个规则

深拷贝和浅拷贝

若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成 员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构 造。

简单来说就是没有指向空间的内置类型只要进行值拷贝浅拷贝就行了，有空间指向的内置类型或者自定义类型要调用其自己写的拷贝构造：如Stack类。

1.c++规定传值传参要进行拷贝构造 因为我们在传常量的时候不是直接传过去，默认要中间生成一个另外空间tem的临时拷贝对象然后传给形参.

形参继续调用拷贝构造。继而无限递归，如果我们加上&就是给形参取别名，就不会出错。

下面是不用&的形式

2.我们不写自动生成只限于没有空间指向的类，如Date类，也就是不用写析构的类型。一般写析构的类都要写拷贝构造。因为它有空间的指向。不然会出错 如：

这是为什么？

因为有空间的指向我们就要用深拷贝，深拷贝是指再开辟一块空间进行拷贝，相对来说浅拷贝只是进行值拷贝。对于日期类这种没有空间指向的类肯定是浅拷贝足够，那么深拷贝就需要写自己的拷贝构造函数了，我们总不希望定义的两个类都指向同一空间，这不乱套了。 如下图st1和st2都指向同一空间。

那么我们知道了一般写析构函数的有空间指向，有空间指向的大概率是深拷贝，深拷贝都要自己写拷贝构造。

下面是我们自己写的栈的拷贝构造：

Stack(const Stack& st)
{
	// 需要对_a指向资源创建同样⼤的资源再拷⻉值
	_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
	if (nullptr == _a)
	{
		perror("malloc申请空间失败!!!");
		return;
	}
	memcpy(_a, st._a, sizeof(STDataType) * st._top);
	_top = st._top;
	_capacity = st._capacity;
}

此时再调试我们就指向不同空间了。

拷⻉构造的特点：

1. 拷⻉构造函数是构造函数的⼀个重载。
2. 拷⻉构造函数的参数只有⼀个且必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语 法逻辑上会引发⽆穷递归调⽤。
3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返 回都会调⽤拷⻉构造完成。
4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成 员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构 造。
5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完 成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但 是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要 我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型 Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现 MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就 需要显⽰写拷⻉构造，否则就不需要。
6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没 有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤ 引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少 拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

二总结

我们先讲了类和对象的前三个默认成员函数，他们都可写可不写，不写就调用其默认生成的。 但是默认生成的有时候不满足需求。我们就要自己写。

我们写的时候要想一想： 第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

三规律

一般写析构函数的类有空间指向（如Stack类），那么一般来说就是深拷贝，那么一般就要写拷贝构造。