Effective C++ 07 为多态基类声明virtual析构函数 笔记

     有多种做法可以记录时间,设计一个TimeKeeper base class和一些derived classes作为不同计时方法是合理的:
1 class TimeKeeper {
2 public:
3   TimeKeeper();
4   ~TimeKeeper();
5   ...
6 };
7 class AtomicClock: public TimeKeeper { ... };   //原子钟
8 class WaterClock: public TimeKeeper { ... };    //水钟
9 class WristWatch: public TimeKeeper { ... };    //腕表

     许多客户只想在程序中使用时间,不想操心时间如何计算等细节,这时候可以设计一个factory(工厂)函数,返回指针指向一个计时对象。Factory函数会“返回一个base class指针,指向新生成之derived class对象”:

1 TimeKeeper* ptk = getTimeKeeper();   //从TimeKeeper继承体系获得一个动态分配对象。
2 ...                                  //运用它...
3 delete ptk;                          //释放它,避免资源泄漏。

      条款13说“依赖客户执行delete动作,基本上便带有某种错误倾向”,条款18则谈到factory函数接口该如何修改以便预防常见之客户错误,但这些在此都是次要的,因为此条款内我们要对付的是上述代码的一个根本弱点:纵使客户把每一件事都做对了,仍然没办法知道程序如何行动。

      问题出在getTimeKeeper返回的指针指向一个derived class对象(例如AtomicClock),而那个对象却经由一个base class(TimeKeeper)有个non-virtual析构函数。这是一个引来灾难的秘诀,因为C++明白指出,当derived class对象经由一个base class指针被删除,而该base class带着一个non-virtual析构函数,其结果未定义——实际执行时通常发生的是对象derived成分没被销毁。如果getTimeKeeper返回指针指向一个AtomicClock对象,其内的AtomicClock成分(也就是声明于AtomicClock class内的成员变量)很可能没被销毁,而AtomicClock的析构函数也未能执行起来。然而其base class成分(也就是TimeKeeper这一部分)通常会被销毁,于是造成诡异的“局部销毁”对象。这可是形成资源泄漏、败坏之数据结构、在调试器上浪费许多时间的绝佳途径喔。

     消除这个问题的做法很简单:给base class一个virtual析构函数。此后删除derived class对象就会如你想要的那般。是的,它会销毁整个对象,包括所有derived class成分:

1 class TimeKeeper {
2 public:
3   TimeKeeper();
4   virtual ~TimeKeeper();
5   ...
6 };
7 TimeKeeper* ptk = getTimeKeeper();
8 ...
9 delete ptk;                             //现在行为正确。

     像TimeKeeper这样的base class除了析构函数之外通常还有其他virtual函数,因为virtual函数的目的是允许derived class的实现得以客制化(见条款34)。例如TimeKeeper就可能拥有一个virtual getCurrentTime,它在不同的derived classes中有不同的实现代码。任何class只要带有virtual函数几乎确定应该也有一个virtual析构函数。

     如果class不含virtual函数,通常表示它并不意图被做一个base class。当class不企图被当作base class,令其析构函数为virtual往往是个馊主意。考虑一个用来表示二维空间点坐标的class:

1 class Point {
2 public:                             //一个二维空间点(2D point)
3   Point(int xCoord, int yCoord);
4   ~Point();
5 private:
6   int x, y;
7 };

     如果int占用32bits,那么Point对象可塞入64-bits缓存器中。更有甚者,这样一个Point对象可被当做一个“64-bits量”传给以其他语言如C或FORTRAN撰写的函数。然而当Point的析构函数是virtual,形势起了变化。

     欲实现出virtual函数,对象必须携带某些信息,主要用来在运行期决定哪一个virtual函数应该被调用。这份信息通常由一个所谓vptr(virtual table pointer)指针指出。vptr指向一个由函数指针构成的数组,称为vtbl(virtual table);每一个带有virtual函数的class都有一个相应的vtbl。当对象的vptr所指的那个vtbl——编译器在其中寻找适当的函数指针。

     virtual函数的实现细节不重要。重要的是如果Point class内含virtual函数,其对象的体积会增加:在32-bits计算机体系结构中将占用64bits(为了存放两个ints)至96bits(两个ints加上vptr);在64-bits计算机体系结构中可能占用64-128bits,因为指针在这样的计算机结构中占64bits。因此,为Point添加一个vptr会增加其对象大小达50%-100%!Point对象不能够塞入一个64-bit缓存器,而C++的Point对象也不再和其他语言(如C)内的相同声明有着一样的结构(因为其他语言的对应物并没有vptr),因此也就不再可能把它传递至(或接受自)其他语言所写的函数,除非你明确补偿vptr——那属于实现细节,也因此不再具有移植性。

     因此,无端地将所有classes的析构函数声明为virtual,就像从未声明它们为virtual一样,都是错误的。许多人的心得是:只有当class内含至少一个virtual函数,才为它声明virtual析构函数。

     即使class完全不待virtual函数,被“non-virtual析构函数问题”给咬伤还是有可能的。举个例子,标准string不含任何virtual函数,但有时候程序员会错误地把它当作base class:

1 class SpecialString: public std::string {   //馊主意!std::string有个non-virtual析构函数
2   ...
3 };

乍看似乎无害,但如果你在程序任意某处无意间将一个pointer-to-SpecialString转换为pointer-to-string,然后将转换得到的那个string指针delete掉,你立刻被流放到“行为不明确”的恶地上:

1 SpecialString* pss = new SpecialString("Impending Doom");
2 std::string* ps;
3 ...
4 ps = pss;       //SpecialString* => std::string*
5 ...
6 delete ps;      //未定义!现实中的*ps的SpecialString资源会泄漏,因为SpecialString析构函数没被调用。

     相同的分析适用于任何不带virtual析构函数的class,包括所有STL容器如vector,list,set,tr1::unordered map(见条款54)等等。如果你曾经企图继承一个标准容器或任何其他“带有non-virtual析构函数”的class,拒绝诱惑吧!(很不幸C++没有提供类似Java的final classes或C#的sealed classes那样的“禁止派生”机制)。

     有时候令class带一个pure virtual析构函数,可能颇为便利。还记得吗,pure virtual函数导致abstract class——也就是不能被实体化的class。也就是说,你不能为那种类型创建对象。然而有时候你希望拥有抽象class,但手上没有任何pure virtual函数,怎么办?由于抽象class总是企图被当作一个base class来用,而又由于base class应该有个virtual析构函数,并且由于pure virtual函数会导致抽象class,因此解法很简单:为你希望它成为抽象的那个class声明一个pure virtual析构函数。下面是个例子:

1 class AWOV {               //AWOV="Abstract w/o Virtuals"
2 public:
3   virtual ~AWOV() = 0;     //声明pure virual析构函数
4 };

     这个class有一个pure virtual函数,所以它是个抽象class,由于它有个virtual析构函数,所有你不用担心析构函数的问题。然而这里有个窍门:你必须为这个pure virtual析构函数提供一份定义:

AWOV::~AWOV() { }    //pure virtual析构函数的定义

     析构函数的运作方式是,最深层派生的那个class其析构函数最先被调用,然后是其每一个base class的析构函数被调用。编译器在AWOV的derived classses的析构函数中创建一个对~AWOV的调用动作,所有你必须为这个函数提供一份定义。如果不这样做,连接器就会发出抱怨。

     “给base classes一个virtual析构函数”,这个规则只适用于polymorphic(带多态性质的)base class身上。这种base classes的设计目的是为了用来“通过base class接口处理derived class对象”。TimeKeeper就是一个polymorphic base class,因为我们希望处理AtomicClock和WaterClock对象,纵使我们只有TimeKeeper指针指向它们。

     并非所有base class的设计目的是为了多态用途。例如标准string和STL容器都不被设计作为base classes使用,更别提多态了。某些classes的设计目的是作为base classes使用,但不是为了多态用途。这样的classes如条款6的Uncopyable和标准程序库的input_iterator_tag(条款47),它们并非被设计用来“经由base class接口处置derived class对象”,因此不需要virtual析构函数。

请记住:

1、polymorphic(带多态性质的) base classes应该声明一个virtual 析构函数。如果class带有任何virtual函数,它就应该拥有一个virtual析构函数。

2、Classes的设计目的如果不是作为base classes使用,或不是为了具备多态性质(polymorphically),就不该声明virtual析构函数。

posted @ 2010-01-03 14:53  shengjin  阅读(588)  评论(0编辑  收藏  举报