【C++】拷贝构造函数，析构函数详解！

💐 🌸 🌷 🍀 🌹 🌻 🌺 🍁 🍃 🍂 🌿 🍄🍝 🍛 🍤
📃个人主页 ：阿然成长日记 👈点击可跳转
📆 个人专栏： 🔹数据结构与算法🔹C语言进阶
🚩 不能则学，不知则问，耻于问人，决无长进
🍭 🍯 🍎 🍏 🍊 🍋 🍒 🍇 🍉 🍓 🍑 🍈 🍌 🍐 🍍

一、析构函数

1.概念

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数是用于在对象被删除之前的清理工作，它在对象生命周期即将结束时会被自动调用。(析构函数可以清理对象并且释放内存)

2.特点

析构函数是特殊的成员函数，其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
   函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数
5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
   生成的默认析构函数，对自定类型成员调用它的析构函数

3.案例

class Time
{
public:
~Time()
{
cout << "~Time()" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}

上述代码定义了两个类Data和Time。其中Data类中存在一个自定义类型变量Time，主方法中只创建了Data对象。那么在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

答：因为main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,_day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，需要调用Time类的析构函数。但是main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器只会调用Date类的析构函 数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部 调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁 ，main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

二、拷贝构造函数

1.拷贝构造函数的引入

如下代码：
创建Stack类和Date类。

class Date
{
public:
	void print(){}
private:
	int _year =1;
	int _month =1;
	int _day =1;
};
class Stack
{
	public:
		Stack(size_t capacity = 10)
		{
			_array = (DataType*)malloc(capacity * sizeof(DataType));
			if (nullptr == _array)
			{
				perror("malloc申请空间失败");
				return;
			}
			
			_size = 0;
			_capacity = capacity;
		}
		void Push(const DataType& data)
		{
			// CheckCapacity();
			_array[_size] = data;
			_size++;
		}
		~Stack()
		{
			if (_array)
			{
				free(_array);
				_array = nullptr;
				_capacity = 0;
				_size = 0;
			}
		}
	private:
		int* _array;
		size_t _size;
		size_t _capacity;
};

使用传值的方式进行调用。

void fun1(Date d)
{
	//...
}
void fun2(Stack s)
{
	//...
}

主函数

int main()
{
	Date d1(1999, 1, 1);
	fun1(d1);

	Stack s1;
	fun2(s1);
	return 0;
}

可以发现运行报错！！！为什么呢？

在C语言中我们遇到这种情况是没有问题的，但是在C++中，由于引进了析构函数，也就是说每次对象试用结束，系统都会自动调用析构函数进行对象的清除工作，正因如此我们在传值的时候，会再次创建一个对象复制过去，当结束函数调用时，会自动调用析构函数对当前对象进行清除，【如果对象中都是变量的话是没有问题的，因为值传递的改变不影响外部的变量，它只是一份拷贝。但是，如果对象中有指针类型的变量，它们指向的是同一位置，第一次函数调用结束后，析构函数已经对指向的位置进行了清除，第二次外部对象结束时，在调用析构函数，就会造成二次析构】。上面例子中Date类中全是普通变量，不会出现问题，造成二次析构。
为了解决上面的问题我们引入了拷贝构造函数。（通过深拷贝解决问题）

2.格式

类名（const 类名 &参数）

2.概念

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

3.特点

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，
   因为会引发无穷递归调用。

例如：

class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
	_year = year;
	_month = month;
	_day = day;
}
下面是拷贝构造！！
Date(const Date& ddd) // 正确写法
Date(const Date ddd) // 错误写法：编译报错，会引发无穷递归
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
private:
	int _year;
	int _month;
	int _day;
};

主函数

int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

• Date(const Date d) // 错误写法：编译报错，会引发无穷递归； 因为【Date d】参数会继续生成一个拷贝构造，如此往复循环。
• *Date(const Date& ddd) // 正确写法 使用传引用就可以解决这个问题。因为ddd就是对象d1的一个别名，this指针指向d2，ddd传给了this，就相当于把d1给了d2,（传递指针也可以，但是很难用），规定必须使用引用。

4.解决引入问题

学到这里我们就可以很好地解决之前抛出的问题了。使用拷贝构造，将原来对象玩玩整整的拷贝一份出来，尤其是内部指针所指向的空间，拷贝时也会去开辟一块新的空间。这样在函数调用函数结束时，系统自动调用其析构造函数时，就不会造成一个地方多次析构了。各玩各的。

5.总结

内置类型系统会默认生成拷贝构造进行值拷贝，对自定义类型调用它的拷贝构造。
并不是所有的对象都需要拷贝构造：

• 类中如果没有涉及资源申请时（例如 new申请空间），拷贝构造函数是否写都可以；
• 一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
• 拷贝构造也是构造，是拷贝构造的一个重载。