C++ 虚析构函数的思考 (Boolan笔记第六周)

关于析构函数我们都听说过基类的析构函数一定要是虚函数。本文就分析这个问题。

首先看看下面的代码：

#include <iostream>
using namespace std;

class Base{
public:
  Base()
  {
    cout<<"Base constructor"<<endl;
  }

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

class Derived : public Base{
public:
  Derived(){
    cout<<"Derived constructor"<<endl;
  }

  ~Derived(){
    cout<<"Derived destructor"<<endl;
  }
};

void test()
{
  Base* pObj = new Derived();
  delete pObj;
}

int main()
{
  test();
  return 0;
}

运行结果为:
Base constructor
Derived constructor
Derived destructor
Base destructor

我们来详细分析一下：

Base* pObj = new Derived();

相当于

Derived* pTemp = new Derived();    
Base* pObj = (Base*)pTemp;  //向上转型

上面第一行会导致Derived()对象被构造，我们知道Derived类构造的时候会由内向外，即先构造基类，再构造子类。这个和输出信息相符。

再来看析构。这里析构就是一行

delete pObj;

编译器这时候是调用~Base()还是~Derived()呢?我的理解是编译器这里根本不知道pObj是指向的一个Base对象还是Derived对象，而是直接根据pObj的类型Base去调用Base的析构函数~Base()。这里我们前面讲过的动态绑定三原则就有用了，因为~Base()前面有virtual，又是基类指针指向派生类对象(指针向上转型)，所以是动态绑定(也就是编译器直到这时候才决定调用哪个函数），必须通过Derived类的虚函数表vtbl来调用相应的虚函数。

那么这里很多问题又来了：
问题一：Derived类里面没有虚函数啊，那Derived的object有没有vtbl呢？
答案是：有的，因为Base类定义了一个虚函数，所以Base类和它的派生类都会有虚函数表。而且，因为~Base()为虚，~Derived()也一定为虚，不管有没有定义virtual。
问题二：Derived的object的vtbl里面有哪些函数呢? ~Base()?~Derived()? 还是两个都有？
答案是：Derived的object的vtbl里面只有一个虚函数~Derived()。
这里我们再深入一下: 如果Base()类里面有多个虚函数，那么Derived()的object的vtbl里面的~Derived()那一项在其vtbl中的索引值 等于 Base()的object的vtbl里面的~Base()那一项在其vtbl中的索引值。

这样，当delete pObj的时候， 编译器流程处理如下

delete pObj;
 –> call pObj; //绑定到Derived的object 
 -> vptr //Derived的object的vptr
 ->vtbl[n]   //Derived的object的vtbl的第n项，n即为Base()的object的vtbl里面的~Base()那一项的索引值。
 -> Derived::~Derived()

注意这里虚析构函数跟其他虚函数有一个不同的地方，那就是基类和派生类的虚析构函数名字不一样（~Base()和~Derived())，Derived()类的object的vtbl里面，~Derived()会overwrite~Base()那一项。

那么问题又来了，前面析构时候调用的结果是

Derived destructor
Base destructor

既然编译器会调用~Derived()，那么为什么~Base()也被调用了呢？这里是因为在C++的编译器里面，动态绑定中，~Derived()后面会自动递归调用其基类的析构函数~Base()，形成一个函数链。这里问题又来了，在run-time的时候，程序调用完~Derived()怎么知道去哪调用~Base()呢？难道有什么地方存了个表，可以从Derived Class找到它的Base Class，并一直回溯上去(Base的Base)? 答案是否定的，因为run-time的时候查表太慢，影响性能。其真正的实现是：编译器在编译的时候就把这个析构函数链写好了，这样在调用的时候直接用可以了。

如果把~Base()前面的virtual去掉，重新编译，则输出为:
Base constructor
Derived constructor
Base destructor

为什么析构的时候只调用~Base()呢? 原因很简单没有virtual了，不满足动态绑定三原则。那么

delete pObj; 

绑定的是静态对象Base。编译器在编译的时候就直接让这里调用~Base()。

根据上面的分析，如果~Base()非虚的话，Base指针指向Derived对象后，删除Base指针不会调用Derived的析构函数。但是Derived的构造函数之前已经调用过了，那么就会有内存泄漏的隐患。所以，~Base()一定要定义成虚函数。

再深入思考一下，为什么基类的构造函数就不需要为虚函数呢？我想了一下，这个原因可能是因为子类对象在被构造的时候，编译器很清楚知道这里是在构造子类对象，不管是

Base *p = new Derived();　　

还是

Derived *p = new Derived();　　

这里很清楚Derived对象要被构造，而且编译器知道Derived的基类是Base，从而会先去调用Base的构造函数, 然后调用Derived的构造函数。

但是子类对象被析构的时候就不一定有这么清楚了，比如说

   delete p;　

这里p是基类指针，但指向子类对象。编译器并不清楚p是指向子类对象的，它只知道p是基类指针，所以只会调用基类的析构函数。　

我做了几次试验，
当~Base()为虚，~Derived()为虚时，delete p时，
~Derived()先调用, ~Base()后调用。
当~Base()为虚，~Derived()为非虚时，delete p时，
~Derived()先调用, ~Base()后调用。
当~Base()为非虚，~Derived()为虚时，delete p时，
只有~Base()被调用。
当~Base()为非虚，~Derived()为非虚时，delete p时，
只有~Base()被调用。

可见当~Base()为虚函数时，不管~Derived()是否为虚，Derived的vtbl都会在相应位置(该位置就是~Base()在Base类的vtbl中的位置)用~Derived()来override ~Base()。当~Derived()被调用后，~Base()紧接着被调用。

而当~Base()为非虚函数时，因为~Base()根本不在Base类的vtbl中(如果Base类有vtbl的话)，所以也谈不上~Derived()来overwrite它了。