虚析构函数详解_虚析构函数在类外定义-CSDN博客

我们知道，用 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 派生出来的类（参见条款 35 及 m33 ）。因为不但要关心敌人目标的总数，也要关心敌人坦克的总数，所以和基类一样，在派生类里也采用了上面提到的同样的技巧：

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 。声明析构函数为虚就会带来你所希望的运行良好的行为：对象内存释放时， enemytank 和 enemytarget 的析构函数都会被调用。

和绝大部分基类一样，现在 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 int 占 16 位，一个 point 对象将刚好适合放进一个 32 位的寄存器中。另外，一个 point 对象可以作为一个 32 位的数据传给用 c 或 fortran 等其他语言写的函数中。但如果 point 的析构函数为虚，情况就会改变。

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

虚函数实现的细节不重要（当然，如果你感兴趣，可以阅读条款 m24 ），重要的是，如果 point 类包含一个虚函数，它的对象的体积将不知不觉地翻番，从 2 个 16 位的 short 变成了 2 个 16 位的 short 加上一个 32 位的 vptr ！ point 对象再也不能放到一个 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

// 会造成泄漏，因为 *pa 的 namedarray

// 永远不会被删除

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

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

这里是一个例子：

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

// virtuals"

public:

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

};

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

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

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

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

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

摘自：http://www.cppblog.com/zmllegtui/archive/2008/10/28/65328.html