虚析构函数如何解决内存泄漏问题

虚析构函数

析构函数的作用是在对象撤销之前做必要的“清理现场”的工作。但派生类的对象从内存中撤销时一般先调用派生类的析构函数，然后再调用基类的析构雨数，但是，如果用new运算符建立了临时对象，若基类中有析构函数，并且定义了一个指向该基类的指针变量，在程序用带指针参数的delele运算符撤销对象时，会发生一个情况， 即系统会只执行基类的析构函数，而不执行派生类的析构函数。

以下示例演示了一个析构函数调用不恰当带来的内存泄漏情况：

// 析构函数调用不恰当带来的内存泄漏.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include <iostream>
using namespace std;
class Base
{
private:
	char* data;                                 //字符指针
public:
	Base( )                                     //无参构造函数
	{
		data = new char[64];                    //动态内存申请
		cout << "Base类构造函数被调用" << endl;
	};
	 ~Base( )                                   //析构函数               
	{
		delete[] data;                          //data指向的内存被释放
		cout << "Base类析构函数被调用" << endl;
	};
};

class Child : public Base
{
private:
	char* m_data;                                 //字符指针
public:
	Child() : Base()                              //派生类的构造函数，初始化表中执行基类的构造函数
	{
		m_data = new char[64];                    //动态内存申请，并将首地址赋给m_data
		cout << "Child类构造函数被调用" << endl;
	};
	~Child()                                       //析构函数
	{
		delete[] m_data;                           // 内存资源释放
		cout << "Child类析构函数被调用" << endl;
	};
};

int main( )
{
	Base *pB = new Child;                          // 动态申请了一块Child大小的内存，赋给Base基类指针
	delete pB;                                     //执行基类析构函数
	return 0;
}

从结果可以看出，Child类的析构函数没有被调用，Child类中的char型指针m_data指向的动态内存泄漏。

虚析构函数是为了解决这样的一个问题， 基类的指针指向派生类对象，并用基类的指针删除派生类对象。

虚析构函数的概念和用法很简单，但它在面向对象程序设计中却是很重要的技巧。声明虚析构函数，即使基类并不需要析构函数，也显式地定义一个函数体为空的虚析构函数，以保证在撤销动态分配空间时能正确地处理。

如果将基类的析构函数声明为虚函数，即使派生类的析构函数与基类的析构函数名字不相同，由该基类所派生的所有派生类的析构函数也都自动成为虚函数。

析构函数名与类名必须相同。一般来说，如果一个类中定义了虚函数，析构函数也应该定义为虚析构函数。

在析构函数前面加上关键字virual 进行说明，称该析构函数为虚析构函数。

虽然构造函数不能被声明为虚函数，但析构函数可以被声明为虚函数。

class 类名
{
    virtual ~析构函数名();
};

将基类中的析构函数定义为虚析构函数可以解决内存泄漏问题。

// 虚析构函数解决内存泄漏问题.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include <iostream>
using namespace std;
class Base
{
private:
	char* data;                                 //字符指针
public:
	Base( )                                     //无参构造函数
	{
		data = new char[64];
		cout << "Base类构造函数被调用" << endl;
	};
	virtual ~Base( )                            //虚析构函数
	{
		delete[] data;
		cout << "Base类析构函数被调用" << endl;
	};
};

class Child : public Base
{
private:
	char* m_data;                                 //字符指针
public:
	Child() : Base()                              //无参构造函数
	{
		m_data = new char[64];
		cout << "Child类构造函数被调用" << endl;
	};
	~Child()                                      //析构函数,继承虚拟virtual
	{
		delete[] m_data;
		cout << "Child类析构函数被调用" << endl;
	};
};

class GrandChild : public Child
{
private:
	char* mm_data;                                 //字符指针
public:
	GrandChild()                                    //无参构造函数
	{
		mm_data = new char[64];
		cout << "GrandChild类构造函数被调用" << endl;
	};
	~GrandChild()                                  //虚析构函数， virtual从继承结构中得来
	{
		delete[] mm_data;
		cout << "GrandChild类析构函数被调用" << endl;
	};
};
int main( )
{
	Base *pB = new Child;                          // 动态申请了一块Child大小的内存，赋给Base基类指针
	delete pB;                                     //Child类的析构函数执行，释放内存，不会泄露


	Child *pC = new GrandChild;                    // 动态申请了一块GrandChild大小的内存，赋给Child基类指针
	delete pC;                                     //GrandChild类的析构函数执行，释放内存，不会泄露

	return 0;
}

从结果可以看出，delete pB和delete pC很好地调用了类层次结构上的所有析构函数，避免了内存泄漏。

关键在于，在Base类中析构函数用virtual修饰，定义为了虚析构函数，这意味着从该基类的素有派生类的析构函数都继承为虚函数。

因此，Child和GrandChild类的析构函数，通过delete指针撤销指针所指的对象时，不再根据指针的类型，而是根据指针指向对象的类型来调用析构函数，很好地完成了内存清理的任务。

注意：虚析构函数的继承与普通虚函数的继承函数名不同，除了~外，析构函数和类同名，所以只要基类的析构函数定义为虚函数，派生类中的析构函数便继承为虚函数。