[C++知识库]Effective C++ 条款07

条款07：为多态基类声明virtual析构函数

一个factory模式下以Dog为base class的demo:

#include<iostream>
#include<cstdio>

class Dog{
public:
    Dog(){std::cout<<"Based ctor!"<<std::endl;}
    ~Dog(){std::cout<<"Based dtor"<<std::endl;}
protected:
    std::string dog_name;
};

class BlackDog:public Dog{
public:
    BlackDog(){std::cout<<"Black ctor!"<<std::endl;}
    ~BlackDog(){std::cout<<"Black dtor!"<<std::endl;}
};

class WhiteDog:public Dog{
public:
    WhiteDog(){std::cout<<"White ctor!"<<std::endl;}
    ~WhiteDog(){std::cout<<"White dtor!"<<std::endl;}
};

class Factory{
public:
    Factory(){printf("Factor ctor!\n");}
    ~Factory(){printf("Factor dtor!\n");}
    Dog*GetDog(const int&x){
        switch(x){
            case 1:return new BlackDog();
            case 2:return new  WhiteDog();
            default:return nullptr;
        }
    }
};

void jj01(){
    Factory factory;
    Dog* ptr=factory.GetDog(1);
    delete ptr;
}

int main(){
    jj01();
    system("pause");
    return 0;
}

运行结果如下：

由运行结果可以看出，当delete由factory函数返回的对象时（也的确应该手动delete），只调用了base class的析构函数——对象的derived成分没有被销毁，于是造成了一种诡异的“局部销毁”现象。

解决此问题的方法很简单：给base class一个virtual析构函数

class Dog{
public:
	...
	virtual ~Dog(){}
};

• 任何class只要带有virtual函数都几乎确定应该也有一个virtual析构函数（至少内含一个virtual函数才为它声明virtual析构函数）
• 无端地将所有classes的析构函数声明为virtual，将极大地增加对象的大小，并使其失去可移植性
• std::string不含任何virtual函数，因此当使用std::string作为base class时，需注意上述“non-virtual函数问题”

如果你希望抽象class，但手上没有任何pure virtual函数，可以为该class声明一个pure virtual析构函数
例如：

class Base{
public:
    Base(){printf("Base ctor!\n");}
    virtual ~Base()=0;
};

Base::~Base(){}//注意此处是重点

class Derived:public Base{
public:
    Derived(){printf("Derived ctor!\n");}
    ~Derived(){printf("Derived dtor!\n");}
};

这样做的好处是：你的class因为带有一个pure virtual析构函数而成为了一个抽象class，而且不用担心“non-virtual析构函数问题”。
但需要注意：析构函数遵循先子类到每个父类的顺序从下往上调用，编译器会在class Derived的析构函数中创建一个对~Base的调用动作，所以必须为这个函数提供一份定义（并不会影响其抽象性）

请记住：

• polymorphic（带多态性质的）base classes应该声明一个virtual析构函数。如果class带有任何virtual函数，它就应该拥有一个virtual析构函数。
• Classes的设计目的如果不是作为base classes使用（如STL中的容器），或不是为了具备多态性（如条款6中的class Uncopyable），就不该声明virtual析构函数。