我们知道,用C++开发的时候,用来做基类的类的析构函数一般都是虚函数。可是,为什么要这样做呢?下面用一个小例子来说明:

有下面的两个类:

class ClxBase

{

public:

    ClxBase() {};

    virtual ~ClxBase() {};

    virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; };

};

class ClxDerived : public ClxBase

{

public:

    ClxDerived() {};

    ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; };

    void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };

};

对于如下代码:

ClxBase *pTest = new ClxDerived;

pTest->DoSomething();

delete pTest;

代码的输出结果是:

Do something in class ClxDerived!

Output from the destructor of class ClxDerived!

这个很简单,非常好理解。

但是,如果把类ClxBase析构函数前的virtual去掉,那输出结果就是下面的样子了:

Do something in class ClxDerived!

也就是说,类ClxDerived的析构函数根本没有被调用!一般情况下类的析构函数里面都是释放内存资源,而析构函数不被调用的话就会造成内存泄漏。我想所有的C++程序员都知道这样的危险性。当然,如果在析构函数中做了其他工作的话,那你的所有努力也都是白费力气。

所以,文章开头的那个问题的答案就是--这样做是为了当用一个基类的指针删除一个派生类的对象时,派生类的析构函数会被调用。

当然,并不是要把所有类的析构函数都写成虚函数。因为当类里面有虚函数的时候,编译器会给类添加一个虚函数表,里面来存放虚函数指针,这样就会增加类的存储空间。所以,只有当一个类被用来作为基类的时候,才把析构函数写成虚函数。


Effective C++条款14:   确定基类有虚析构函数  

 有时,一个类想跟踪它有多少个对象存在。一个简单的方法是创建一个静态类成员来统计对象的个数。这个成员被初始化为0,在构造函数里加1,析构函数里减1。(条款m26里说明了如何把这种方法封装起来以便很容易地添加到任何类中,“my   article   on   counting   objects”提供了对这个技术的另外一些改进)  

 设想在一个军事应用程序里,有一个表示敌人目标的类:  

 class   enemytarget   {  

 public:  

      enemytarget()   {   ++numtargets;   }  

      enemytarget(const   enemytarget&)   {   ++numtargets;   }  

      ~enemytarget()   {   --numtargets;   }  

      static   size_t   numberoftargets()  

      {   return   numtargets;   }  

      virtual   bool   destroy();               //   摧毁enemytarget对象后  

                                            //   返回成功  

 private:  

      static   size_t   numtargets;           //   对象计数器  

 };  

 //   类的静态成员要在类外定义;  

 //   缺省初始化为0  

 size_t   enemytarget::numtargets;  

这个类不会为你赢得一份政府防御合同,它离国防部的要求相差太远了,但它足以满足我们这儿说明问题的需要。  

敌人的坦克是一种特殊的敌人目标,所以会很自然地想到将它抽象为一个以公有继承方式从enemytarget派生出来的类(参见条款35m33)。因为不但要关心敌人目标的总数,也要关心敌人坦克的总数,所以和基类一样,在派生类里也采用了上面提到的同样的技巧:  

 class   enemytank:   public   enemytarget   {  

 public:  

      enemytank()   {   ++numtanks;   }  

      enemytank(const   enemytank&   rhs)  

      :   enemytarget(rhs)  

      {   ++numtanks;   }  

      ~enemytank()   {   --numtanks;   }  

      static   size_t   numberoftanks()  

      {   return   numtanks;   }  

      virtual   bool   destroy();  

 private:  

      static   size_t   numtanks;                   //   坦克对象计数器  

 };  

(写完以上两个类的代码后,你就更能够理解条款m26对这个问题的通用解决方案了。)  

最后,假设程序的其他某处用new动态创建了一个enemytank对象,然后用delete删除掉:  

 enemytarget   *targetptr   =   new   enemytank;  

 ...  

 delete   targetptr;  

到此为止所做的一切好象都很正常:两个类在析构函数里都对构造函数所做的操作进行了清除;应用程序也显然没有错误,用new生成的对象在最后也用delete删除了。然而这里却有很大的问题。程序的行为是不可预测的——无法知道将会发生什么。  

c++语言标准关于这个问题的阐述非常清楚:当通过基类的指针去删除派生类的对象,而基类又没有虚析构函数时,结果将是不可确定的。这意味着编译器生成的代码将会做任何它喜欢的事:重新格式化你的硬盘,给你的老板发电子邮件,把你的程序源代码传真给你的对手,无论什么事都可能发生。(实际运行时经常发生的是,派生类的析构函数永远不会被调用。在本例中,这意味着当targetptr   删除时,enemytank的数量值不会改变,那么,敌人坦克的数量就是错的,这对需要高度依赖精确信息的部队来说,会造成什么后果?)  

为了避免这个问题,只需要使enemytarget的析构函数为virtual。声明析构函数为虚就会带来你所希望的运行良好的行为:对象内存释放时,enemytankenemytarget的析构函数都会被调用。    

和绝大部分基类一样,现在enemytarget类包含一个虚函数。虚函数的目的是让派生类去定制自己的行为(见条款36),所以几乎所有的基类都包含虚函数。  

如果某个类不包含虚函数,那一般是表示它将不作为一个基类来使用。当一个类不准备作为基类使用时,使析构函数为虚一般是个坏主意。请看下面的例子,这个例子基于arm(the   annotated   c++   reference   manual)一书的一个专题讨论。  

 //   一个表示2d点的类  

 class   point   {  

 public:  

      point(short   int   xcoord,   short   int   ycoord);  

      ~point();  

 private:  

      short   int   x,   y;  

 };  

如果一个short   int16位,一个point对象将刚好适合放进一个32位的寄存器中。另外,一个point对象可以作为一个32位的数据传给用cfortran等其他语言写的函数中。但如果point的析构函数为虚,情况就会改变。  

实现虚函数需要对象附带一些额外信息,以使对象在运行时可以确定该调用哪个虚函数。对大多数编译器来说,这个额外信息的具体形式是一个称为vptr(虚函数表指针)的指针。vptr指向的是一个称为vtbl(虚函数表)的函数指针数组。每个有虚函数的类都附带有一个vtbl。当对一个对象的某个虚函数进行请求调用时,实际被调用的函数是根据指向vtblvptrvtbl里找到相应的函数指针来确定的。  

虚函数实现的细节不重要(当然,如果你感兴趣,可以阅读条款m24),重要的是,如果point类包含一个虚函数,它的对象的体积将不知不觉地翻番,从216位的short变成了216位的short加上一个32位的vptrpoint对象再也不能放到一个32位寄存器中去了。而且,c++中的point对象看起来再也不具有和其他语言如c中声明的那样相同的结构了,因为这些语言里没有vptr。所以,用其他语言写的函数来传递point也不再可能了,除非专门去为它们设计vptr,而这本身是实现的细节,会导致代码无法移植。  

所以基本的一条是,无故的声明虚析构函数和永远不去声明一样是错误的。实际上,很多人这样总结:当且仅当类里包含至少一个虚函数的时候才去声明虚析构函数。  

这是一个很好的准则,大多数情况都适用。但不幸的是,当类里没有虚函数的时候,也会带来非虚析构函数问题。   例如,条款13里有个实现用户自定义数组下标上下限的类模板。假设你(不顾条款m33的建议)决定写一个派生类模板来表示某种可以命名的数组(即每个数组有一个名字)  

 template<class   t>                                 //   基类模板  

 class   array   {                                         //   (来自条款13)  

 public:  

      array(int   lowbound,   int   highbound);  

      ~array();  

 private:  

      vector<t>   data;  

      size_t   size;  

      int   lbound,   hbound;  

 };  

 template<class   t>  

 class   namedarray:   public   array<t>   {  

 public:  

      namedarray(int   lowbound,   int   highbound,   const   string&   name);  

      ...  

 private:  

      string   arrayname;  

 };  

如果在应用程序的某个地方你将指向namedarray类型的指针转换成了array类型的指针,然后用delete来删除array指针,那你就会立即掉进“不确定行为”的陷阱中。  

 namedarray<int>   *pna   =  

      new   namedarray<int>(10,   20,   "impending   doom");  

 array<int>   *pa;  

 ...  

 pa   =   pna;                                 //   namedarray<int>*   ->   array<int>*  

 ...  

 delete   pa;                               //   不确定!   实际中,pa->arrayname  

                                                    //   会造成泄漏,因为*panamedarray  

                                                    //   永远不会被删除  

现实中,这种情形出现得比你想象的要频繁。让一个现有的类做些什么事,然后从它派生一个类做和它相同的事,再加上一些特殊的功能,这在现实中不是不常见。namedarray没有重定义array的任何行为——它继承了array的所有功能而没有进行任何修改——它只是增加了一些额外的功能。但非虚析构函数的问题依然存在(还有其他问题,参见m33  

最后,值得指出的是,在某些类里声明纯虚析构函数很方便。纯虚函数将产生抽象类——不能实例化的类(即不能创建此类型的对象)。有些时候,你想使一个类成为抽象类,但刚好又没有任何纯虚函数。怎么办?因为抽象类是准备被用做基类的,基类必须要有一个虚析构函数,纯虚函数会产生抽象类,所以方法很简单:在想要成为抽象类的类里声明一个纯虚析构函数。  

这里是一个例子:  

 class   awov   {                                 // awov =   "abstract   w/o  

                                                 //   virtuals"  

 public:  

      virtual   ~awov()   =   0;             //   声明一个纯虚析构函数  

 };  

这个类有一个纯虚函数,所以它是抽象的,而且它有一个虚析构函数,所以不会产生析构函数问题。但这里还有一件事:必须提供纯虚析构函数的定义:  

 awov::~awov()   {}                       //   纯虚析构函数的定义  

这个定义是必需的,因为虚析构函数工作的方式是:最底层的派生类的析构函数最先被调用,然后各个基类的析构函数被调用。这就是说,即使是抽象类,编译器也要产生对~awov的调用,所以要保证为它提供函数体。如果不这么做,链接器就会检测出来,最后还是得回去把它添上。  

可以在函数里做任何事,但正如上面的例子一样,什么事都不做也不是不常见。如果是这种情况,那很自然地会想到将析构函数声明为内联函数,从而避免对一个空函数的调用所产生的开销。这是一个很好的方法,但有一件事要清楚。  

因为析构函数为虚,它的地址必须进入到类的vtbl(见条款m24)。但内联函数不是作为独立的函数存在的(这就是“内联”的意思),所以必须用特殊的方法得到它们的地址。条款33对此做了全面的介绍,其基本点是:如果声明虚析构函数为inline,将会避免调用它们时产生的开销,但编译器还是必然会在什么地方产生一个此函数的拷贝。