C++语言中的虚析构和纯虚析构【详细讲解】

1、为什么有虚析构和纯虚析构？

多态使用时，如果子类中有【成员属性】是在【堆区开辟空间】（malloc或者new），那么父类指针（vfptr指针）在释放时无法调用子类的析构代码，这就会造成内存泄漏。

内存泄漏：开辟了一块空间（堆区），但是没有释放，后期其他程序无法访问被占用的空间。如此往复，越来越多的内存空间被占用，导致系统内存满了，系统发生崩溃。

2、虚析构和纯虚析构的作用

1）可以解决父类指针释放子类对象的问题，这样就可以实现父类调用子类的析构函数，进行内存的释放。【防止内存泄露的发生】

2）虚析构/纯虚析构都具有函数体，这与普通纯虚函数有所不同。【即需要在析构函数中编写函数体】

3、实例

1）有瑕疵的程序：

#include <iostream>

using namespace std;
//基类
class basic_A {
public:
	basic_A(int a, int b): num1(a), num2(b)
	{
		cout << "基类中的构造函数！！！" << endl;
	}
	~basic_A()
	{
		cout << "基类中的析构函数！！！" << endl;
	}
	virtual int make() = 0;   //纯虚函数
protected:
	int num1;
	int num2;
};

//派生类
class derive_ADD:public basic_A {
public:
	derive_ADD(int a, int b) :basic_A(a, b)    //使用初始化列表来给基类中的成员属性进行赋值
	{
		pa = new int(10);      //通过new在堆区开辟一个空间
		cout << "派生类中的构造函数！！！" << endl;
	}
	~derive_ADD()
	{
		delete pa;            //使用delete将申请的空间释放
		cout << "派生类中的析构函数！！！" << endl;
	}
	int make()
	{
		return num1 + num2;
	}
	int* pa;  //在派生类中定义一个指针
};

int main()
{
	basic_A* p = new derive_ADD(10, 20);  //通过父类的指针来指向派生类的对象
	cout << "-------------------------------------" << endl;
	delete p;
	return 0;
}

运行结果：

基类中的构造函数！！！
派生类中的构造函数！！！
-------------------------------------
基类中的析构函数！！！

由此运行结果可以看出，基类的指针在释放时，没有调用派生类的析构函数。因此，在派生类中pa指针申请的空间没有被释放掉，产生了内存泄漏。【通过虚析构或者纯虚析构来解决这个问题】

2）通过虚析构改进的程序：

#include <iostream>

using namespace std;
//基类
class basic_A {
public:
	basic_A(int a, int b): num1(a), num2(b)
	{
		cout << "基类中的构造函数！！！" << endl;
	}
	virtual ~basic_A()    //使用纯虚析构来实现父类指针来调用子类中的析构函数的作用，防止内存泄露的发生
	{
		cout << "基类中的析构函数！！！" << endl;
	}
	virtual int make() = 0;   //纯虚函数
protected:
	int num1;
	int num2;
};

//派生类
class derive_ADD:public basic_A {
public:
	derive_ADD(int a, int b) :basic_A(a, b)    //使用初始化列表来给基类中的成员属性进行赋值
	{
		pa = new int(10);      //通过new在堆区开辟一个空间
		cout << "派生类中的构造函数！！！" << endl;
	}
	~derive_ADD()
	{
		delete pa;            //使用delete将申请的空间释放
		cout << "派生类中的析构函数！！！" << endl;
	}
	int make()
	{
		return num1 + num2;
	}
	int* pa;  //在派生类中定义一个指针
};

int main()
{
	basic_A* p = new derive_ADD(10, 20);  //通过父类的指针来指向派生类的对象
	cout << "-------------------------------------" << endl;
	delete p;
	return 0;
}

运行结果：

基类中的构造函数！！！
派生类中的构造函数！！！ 
-------------------------------------
派生类中的析构函数！！！
基类中的析构函数！！！

3）通过纯虚析构改进的程序：

【注意：纯虚析构需要在类内声明，类外定义】

#include <iostream>

using namespace std;
//基类
class basic_A {
public:
	basic_A(int a, int b): num1(a), num2(b)
	{
		ba = new int(10);
		cout << "基类中的构造函数！！！" << endl;
	}
	virtual ~basic_A() = 0;     //纯虚函数类内声明
	virtual int make() = 0;     //纯虚函数
protected:
	int num1;
	int num2;
	int* ba;
};
//纯虚析构类外定义
//【注意这里的纯虚析构函数是具有函数体的，因为父类中的成员属性可能也在堆区申请了空间，因此需要通过父类中的析构函数进行释放】
basic_A::~basic_A()    
{
	delete ba;
	cout << "基类中的析构函数！！！" << endl;
}
//派生类
class derive_ADD:public basic_A {
public:
	derive_ADD(int a, int b) :basic_A(a, b)    //使用初始化列表来给基类中的成员属性进行赋值
	{
		pa = new int(10);      //通过new在堆区开辟一个空间
		cout << "派生类中的构造函数！！！" << endl;
	}
	~derive_ADD()
	{
		delete pa;            //使用delete将申请的空间释放
		cout << "派生类中的析构函数！！！" << endl;
	}
	int make()
	{
		return num1 + num2;
	}
	int* pa;  //在派生类中定义一个指针
};

int main()
{
	basic_A* p = new derive_ADD(10, 20);  //通过父类的指针来指向派生类的对象
	cout << "-------------------------------------" << endl;
	delete p;
	return 0;
}

运行结果：

基类中的构造函数！！！
派生类中的构造函数！！！
-------------------------------------
派生类中的析构函数！！！
基类中的析构函数！！！

4、总结

1）虚析构/纯虚析构只有当派生类中含有堆区开辟的空间的时候才使用；

2）虚析构/纯虚析构是通过基类指针来释放子类对象的；

3）具有纯虚析构的类也称为抽象类。