直接的讲，C++中基类采用virtual虚析构函数是为了防止内存泄漏。具体地说，如果派生类中申请了堆内存空间，并在其析构函数中对这些内存空间进行释放。假设基类中采用的是非虚析构函数，当删除基类指针指向的派生类对象时就不会触发动态绑定，因而只会调用基类的析构函数，而不会调用派生类的析构函数。那么在这种情况下，派生类中申请的空间就得不到释放从而产生内存泄漏。所以，为了防止这种情况的发生，C++中基类的析构函数应采用virtual虚析构函数。

代码演示

现有Base基类，其析构函数为非虚析构函数。Derived1和Derived2为Base的派生类，这两个派生类中均有以string* 指向存储其name的地址空间，name对象是通过new创建在堆上的对象，因此在析构时，需要显式调用delete删除指针归还内存，否则就会造成内存泄漏。
基类：

#include <iostream>
#include <string>
using namespace std;
class Base {public:Base():age_(new int(18)) {cout << "Base()" << endl;}~Base(){delete age_;cout << "~Base()" << endl;}void showAge(){ cout <<"Base::age_==" << *age_ << endl;};virtual void showName()=0;
private:int age_;
};

//派生类Derived1 
class Derived1 : public Base {public:Derived1():name_(new string("NULL")) {}Derived1(const string& n):name_(new string(n)) {}~Derived1() {delete name_;cout << "~Derived1(): name_ has been deleted." << endl;}void showName() {cout << "Derived1::name_==" << *name_ << endl;	}private:string* name_;
};//派生类Derived2 
class Derived2 : public Base {public:Derived2():name_(new string("NULL")) {}Derived2(const string& n):name_(new string(n)) {}~Derived2() {delete name_;cout << "~Derived2(): name_ has been deleted." << endl;}void showName() {cout << "Derived2::name_==" << *name_ << endl;	}private:string* name_;
};

测试调用：

int main() {Derived1* d1 = new Derived1();Derived2 d2 = Derived2("Bob");delete d1;return 0;
}

d1为Derived1类的指针，它指向一个在堆上创建的Derived1的对象；
d2为一个在栈上创建的对象；
其中d1所指的对象需要我们显式的用delete 指针才会释放堆中Derived1对象，进而自动调用其析构函数；
如果不对d1进行delete，那么d1指针变量在其生命周期结束时，系统只会回收Derived1类指针d1（注意d1不是Derived1类对象，
真实的Derived1对象在堆内存中,而d1指针指向堆内存中的Derived1对象），而堆内存中的Derived1对象还在，故而不会触发Derived1对象的析构函数。
d2对象在其生命周期结束时，系统会自动调用其析构函数。看下其运行结果：

可以这么说，只有真正的类的实例（对象）所占内存，被释放时，才有可能触发其对应的析构函数，在析构函数中，对其对象中申请的堆内存空间，进行进一步的释放（比如上方name_指针指向的堆内存）。

上方的示例中Base基类的析构函数并不是虚析构函数，上方的执行结果，派生类的析构函数被调用了，正常的释放了其申请的内存资源。这两者并不矛盾，因为无论是d1还是d2，两者都属于静态绑定，而且其静态类型恰好都是派生类，因此，在析构的时候，即使基类的析构函数为非虚析构函数，也会调用相应派生类的析构函数。

下面我们来看下，当发生动态绑定时，也就是当用基类指针指向派生类对象时，这时候采用delete显式删除指针所指对象时，如果Base基类的析构函数没有加virtual，会发生什么情况？

int main() {Base* base[2] = {//base是一个指针数组，数组中的指针变量类型为Base*new Derived1(),//堆中生成Derived1对象，返回的对象地址用Base*指针来接收new Derived2("Bob")//同上      };for (int i = 0; i != 2; ++i) {delete base[i];//这里是delete 基类类型的指针}//测试当 delete base[i];时是否for (int i = 0; i != 2; ++i) {base[i]->show();    }return 0;
}

执行结果如下：

注意：delete base[i];//这里是delete 基类类型的指针，首先判断指针的静态类型即基类的析构函数是否为虚析构函数，如果不是虚析构函数，就是静态绑定，不会调派生类的析构函数，直接调指针的静态类型（基类类型）的析构函数，因为指针的静态类型为基类类型。如果是虚析构函数,就是动态绑定，会先调派生类的析构函数，然后再调基类的析构函数。虚函数是实现多态（动态绑定）的基础。

从上面结果我们看到，尽管派生类中定义了析构函数来释放其申请的资源，但是并没有得到调用。原因是基类指针指向了派生类对象，而基类中的析构函数却是非virtual的，之前讲过，虚函数是动态绑定的基础。现在析构函数不是virtual的，因此不会发生动态绑定，而是静态绑定，指针的静态类型为基类指针，因此在delete时候只会调用基类的析构函数，而不会调用派生类的析构函数。这样，在派生类中申请的资源就不会得到释放，就会造成内存泄漏，这是相当危险的：如果系统中有大量的派生类对象被这样创建和销毁，就会有内存不断的泄漏，久而久之，系统就会因为缺少内存而崩溃。

从上图中也可以看到，虽然派生类的析构函数没有得到执行，但是派生类对象在堆内存是被释放了，在基类的析构函数中需要释放的内存被释放了，而只是在派生类对象的析构函数中，需要回收那部分内存没有得到释放。对象的释放，会触发析构函数的执行，但是析构函数没有被执行（执行的是基类的析构函数），并不代表对象没有被释放。

也就是说，在基类的析构函数为非虚析构函数的时候，并不一定会造成内存泄漏；当派生类对象的析构函数中有内存需要收回，并且在编程过程中采用了基类指针指向派生类对象，如为了实现多态，并且通过基类指针将该对象销毁，这时，就会因为基类的析构函数为非虚析构函数而不触发动态绑定，从而没有调用派生类的析构函数而导致内存泄漏。
因此，为了防止这种情况下内存泄漏的发生，最好将基类的析构函数写成virtual虚析构函数。

下面把Base基类的析构函数改为虚析构函数：

virtual ~Base(){delete age_;cout << "~Base()" << endl;}

这样就会实现动态绑定，派生类的析构函数就会得到调用，然后再调用基类的析构函数，从而避免了内存泄漏。

创建子类对象时：
构造函数的执行顺序： 先执行基类的构造函数（如果基类还有自己的父类，那就先执行它父类的构造，一层一层的执行），再执行子类
的构造函数。
默认都是调用基类的无参构造，想要调用基类的有参构造，需要子类在构造函数，参数列表里显示调用基类有参
构造。
注意：不管基类是抽象类都会调其构造函数，因为创建子类对象时，调用基类的构造函数，并不会产生基类对象。只是借助基类的构造函
数，来初始化，那些子类从基类继承而来的那些成员属性，这点可以根据隐式的this来判断。

析构函数的执行顺序： 先执行子类的析构函数，再执行基类的析构函数，如果基类还有自己的父类，那就再执行它父类的析构，一层一层
的执行。
注意：子类对象在销毁时，调用基类的析构函数，基类析构函数里面，需要处理的数据也是子类对象下的数据。这点可以根据隐式的this
来判断。

注意：上图中继承基类时应该去掉:public后的class关键字，这里就不在修改图了。

析构函数和虚析构函数特点：
当基类的析构函数是虚函数时，那么它的派生类的析构函数也默认是虚函数，隐式的和显示的都是虚函数。
如果基类的析构函数不是虚函数，而此时它的派生类的析构函数手动加上virtual变为虚函数，那么当delete 基类指针时，判断基类的析构
函数不是虚函数，那么也是静态绑定。不可能会触发派生类的析构函数。

记住一句话：虚函数是实现类多态的基础，关于虚函数的动态绑定原理，可以看这篇文章：虚函数讲解。
另外需要注意的是：构造函数及析构函数都不能被继承。而且构造函数不能为虚函数，析构函数可以为虚函数。

故： 继承时，要养成的一个好习惯就是，基类析构函数中，加上virtual。