为什么要将基类的析构函数声明为虚函数

原因是因为多态的存在

       我们大家都知道，在C++ 中，当一个对象销毁时，析构函数是用来对类对象和对象成员进行释放内存和做一些其他的cleanup操作。析构函数靠～符号来区分，～ 出现在 析构函数名字的前面，  当我们去定义一个 虚析构函数时，你只需要简单的的在～符号前面 加一个  virtual标志就可以了。
       为什么需要将析构函数声明为 虚函数，我们最好用几个例子来验证一下，我们首先以一个 不使用虚析构函数的例子开始，然后我们使用一个使用析构函数的例子。一旦看到了其中的区别，你就会明白 为什么需要将析构函数声明为虚函数。让我们开始看一下代码。

       Example  without a Virtual Destructor:

#include <iostream>
using namespace std;

class Base
{
public:
    Base(){ cout<<"Constructing Base\n";}

   // this is a destructor:
   ~Base(){ cout<<"Destroying Base\n";}
};

class Derive: public Base
{
public:
   Derive(){ cout<<"Constructing Derive\n";}

   ~Derive(){ cout<<"Destroying Derive\n";}
 };

int main()
{
	Base *basePtr = new Derive();
    delete basePtr;
    return 0;
}

运行结果如下：

根据上面的输出，我们可以看到当我们新建一个指向Deriver类型对象指针的时候，构造函数按照由基类到派生类的顺序依次调用，但是当我们删除指向Deriver 的基类指针时， Deriver类中的析构函数没有被调用，而是只调用了Base的析构函数。（原因可参考：编译期绑定和运行期绑定）

当我们将基类的析构函数声明为虚函数时

  Example with a Virtual Destructor:

我们需要做的就是修改Base 类中的析构函数，在～前面加上virtual关键字。

class Base
{
public:
    Base(){ cout<<"Constructing Base\n";}

   // this is a destructor:
   virtual ~Base(){ cout<<"Destroying Base\n";}
};

改变之后，运行结果如下：

我们在基类中将析构函数声明为虚函数，就表示在使用析构函数时，是采用运行期绑定的。那么delete basePtr的时候运行的是根据basePtr指向的具体类型来调用析构函数。

如果你在 派生类中 分配了 内存空间的话，没有将基类的析构函数声明为虚析构函数，很容易发生内存泄漏事件。
例子：

#include <iostream>
using namespace std;

class Base
{
public:
	Base(){ data = new char[10];}

 // this is a destructor:

	~Base(){ cout << "destroying Base data[]";delete []data;}
private:
	char *data;
};

class Derive: public Base
{
public:
	Derive(){ D_data = new char[10];}

	~Derive(){ cout << "destroying Derive data[]";delete []D_data;}
private:
	char *D_data;
 };

main()
{
   Base *basePtr = new Derive();
   delete basePtr;
   return 0;
}

我们在基类和派生类中都个分配了 10个 字节的空间，这些空间应该由程序员来释放，如果没有释放掉的话，就会造成内存泄漏。

运行结果如下：

我们可以看到只删除了基类的分配的空间，这个时候派生类的对象的空间没有删除，内存泄漏。

另外一个例子：

#include <iostream>
using namespace std;

class CBase
{
public:
    CBase(){data = new char[64];}
    ~CBase(){delete [] data;}
private:
    char *data;
};

class CFunction
{
public:
    CFunction(){};
    ~CFunction(){};
};

class CFunctionEx : public CFunction
{
public:
    CFunctionEx(){};
    ~CFunctionEx(){};
private:
    CBase m_cbase;
};

void main()
{
	CFunction *pCFun = new CFunctionEx;
	delete pCFun;
}

这里CfunctionEx和Cfunction中本身并没有分配内存，应该不会有内存泄漏。和上例一样当删除pCFun时，它只调用了Cfunction的析构函数而没调用CfunctionEx的析构函数，但CfunctionEx本身并没分配内存。所以发生内存泄露的地方是m_cbase,因为它是CBase的实例且是CfunctionEx成员变量，当CfunctionEx的析构函数没有被调用时，当然m_cbase的析构函数也没有被调用，所以CBase中分配的内存被泄漏。
解决以上问题的方法很简单，就是使基类Cfunction的析构函数为虚函数就可以了。

这样就得出一个结论：当你的基类的析构函数不为虚函数的话，其子类中所有的成员变量的类中分配的内存将可能泄漏。将基类的析构函数设为virtual型，则基类的所有派生类的析构函数都会自动设置为virtual型，这保证了任何情况下，都不会出现由于析构函数没有被调用而导致的内存泄漏。