读书笔记《Effective C++》条款07：为多态基类声明virtual析构函数

开篇例子，有许多种做法可以记录时间，因此，设计一个TimeKeeper base class和一些derived classes作为不同的计时方法。

class TimeKeeper {public:TimeKeeper() {std::cout << "TimeKeeper constructor" << std::endl;}~TimeKeeper() {std::cout << "TimeKeeper destructor" << std::endl;}};class AtomicClock : public TimeKeeper {public:AtomicClock() {std::cout << "AtomicClock constructor" << std::endl;}~AtomicClock() {std::cout << "AtomicClock destructor" << std::endl;}};class WaterClock : public TimeKeeper {public:WaterClock() {std::cout << "WaterClock constructor" << std::endl;}~WaterClock() {std::cout << "WaterClock destructor" << std::endl;}};class WristWatch : public TimeKeeper {public:WristWatch() {std::cout << "WristWatch constructor" << std::endl;}~WristWatch() {std::cout << "WristWatch destructor" << std::endl;}};

许多客户只想在程序中使用时间，不想操心时间如何计算等细节，这时候我们可以设计Factory函数，返回指针指向一个计时对象。Factory函数会“返回一个base class指针，指向新生成的derived class对象”：

//返回一个指针，指向一个TimeKeeper派生类的动态分配对象TimeKeeper* getTimeKeeper(){TimeKeeper *ptk = new AtomicClock;return ptk;}

为遵守Factory函数的规矩，被getTimeKeeper()返回的对象必须位于heap。因此为了避免泄露内存和其他资源，将Factory函数返回的每一个对象是当地delete掉很重要：

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

问题在getTimeKeeper返回的指针指向一个derived class对象（例如AtomicClock），而那个对象却经由一个base class指针（例如一个TimeKeeper*指针）被删除，而目前的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析构函数。这样，delete derived class对象会销毁整个对象，包括所有derived class成分。

修改上述例子：

class TimeKeeper {public:TimeKeeper() {std::cout << "TimeKeeper constructor" << std::endl;}virtual ~TimeKeeper() {std::cout << "TimeKeeper destructor" << std::endl;}};class AtomicClock : public TimeKeeper {public:AtomicClock() {std::cout << "AtomicClock constructor" << std::endl;}~AtomicClock() {std::cout << "AtomicClock destructor" << std::endl;}};class WaterClock : public TimeKeeper {public:WaterClock() {std::cout << "WaterClock constructor" << std::endl;}~WaterClock() {std::cout << "WaterClock destructor" << std::endl;}};class WristWatch : public TimeKeeper {public:WristWatch() {std::cout << "WristWatch constructor" << std::endl;}~WristWatch() {std::cout << "WristWatch destructor" << std::endl;}};//返回一个指针，指向一个TimeKeeper派生类的动态分配对象TimeKeeper* getTimeKeeper(){TimeKeeper *ptk = new AtomicClock;return ptk;}TimeKeeper* ptk = getTimeKeeper();//从TimeKeeper继承体系获得一个动态分配对象//运用它...delete ptk;//释放它，避免资源泄露，现在行为正确

运行结果如下：

像TimeKeeper这样的base class除了析构函数之外通常还有其他virtual函数，因为virtual函数的目的是允许derived class的实现得以客制化。任何class只要带有virtual函数都几乎确定应该也要有一个virtual析构函数。

如果class不含virtual函数，通常表示它并不意图被用做一个base class。当class不企图被当做base class，令其析构函数为virtual往往是个馊主意。

举个例子：

class Point {public:Point(int xCoord, int yCoord);~Point();private:int x;int y;};std::cout << "sizeof(Point): " << sizeof(Point) << std::endl;

从运行结果（32bit计算机体系结构，一个int的大小是4Byte）来看，Point占用内存大小是8Byte。

当Point class不企图被当做base class时，我们尝试令其析构函数为virtual。

class Point {public:Point(int xCoord, int yCoord);virtual ~Point();private:int x;int y;};std::cout << "sizeof(Point): " << sizeof(Point) << std::endl;

我们来看看运行结构，发现Point的内存大小从8Byte（存放两个int）增长至12Byte（两个int加上vptr）。

下面，我们来说下原因。C++中，欲实现出virtual函数，对象必须携带某些信息，主要用来在运行期间决定哪一个virtual函数该被调用。这份信息通常是由一个所谓vptr（virtual table pointer）指针指出。vptr指向一个由函数指针构成的数组，称为vtbl（virtual table）；每一个带有virtual函数的class都有一个相应的vtbl。当对象调用某一virtual，实际被调用的函数取决于该对象的vptr所指的那个vtbl——编译器在其中寻找适当的函数指针。

如果Point class内含virtual函数，其对象的体积会增大。这样会导致明确需要Point对象能够正确体现出size的用途出错。

因此，无端将所有class的析构函数声明为virtual，就像从未声明它们为virtual一样都是错误的。

许多人的心得：只有当class内含至少一个virtual函数（也就是说打算被当做base class），才把它的析构函数声明为virtual。

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

class SpecialString : public std::string {//馊主意！std::string有个non-virtual析构函数};

咋看起来似乎没有问题，但如果在程序任意某处无意间将一个pointer-to-SpecialString转换为一个pointer-to-string，然后将转换所得的那个string指针delete掉，就立刻导致行为不明确的严重问题。

SpecialString* pss = new SpecialString;std::string* ps;//...ps = pss;//SpecialString* = > std::string*//...delete ps;//出问题：*ps的SpecialString资源会泄露，因为SpecialString析构函数没被调用

相同的分析适用于任何不带virtual析构函数的class，包括所有STL容器如：vector，list，set等等。如果你曾经企图继承一个标准容器或任何其他“带有non-virtual析构函数”的class，拒绝吧！

幸运的是，C++ 11标准中增加了final，类似于Java的final class或C#的sealed class那样的“禁止派生”机制。

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

例子：

class AWOV {public:virtual ~AWOV() = 0;//声明pure virtual析构函数};AWOV::~AWOV(){//pure virtual析构函数的定义}

这个class有一个pure virtual函数，所以它是个abstract class，又由于它有个virtual析构函数，所以不需要担心析构函数的问题。

析构函数运作方式：最深层派生的那个class其析构函数最新被调用，然后是其每一个base class的析构函数被调用。

编译器会在AWOV的derived classes的析构函数中创建一个对~AWOV的调用动作，所以必须为这个函数提供定义，否则连接器会报错。

“给base class一个virtual析构函数”，这个规则只适用于带多态性质的base class上。这种base class的设计目的是为了用来”通过base class接口处理derived class对象“。

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

要点：

1.带多态性质的base class应该声明一个virtual析构函数，如果class带有任何virtual函数，它就应该拥有一个virtual析构函数。

2.class的设计目的如果不是作为base class使用，或不是为了具备多态性，就不该声明virtual析构函数。