析构函数为什么是虚函数-析构函数定义为虚函数的作用 收藏 0

CPU眼里的：析构函数

“为什么析构函数必须是虚函数？难道没有另外一种答案吗？”

01

提出问题

构造函数和析构函数，分别用于类对象（class类型的变量）的初始化和相关资源的清理工作。这看上去非常的自动、方便，但千万不要掉以轻心，C++的每一个语法糖背后，都有暗坑。

例如，为了保证析构函数能够被正确的调用，我们必须把析构函数定义成：虚函数，也就是要加上关键字：virtual；那作为孪生兄弟的构造函数，为什么不需要定义成虚函数呢？好了，让我们一起用CPU的视角，解读它们背后的故事吧。

02

代码分析

打开Compiler Explorer，先定义一个简单的类A，简单的为它定义一个构造函数和析构函数；随后再定义一个派生类B，也简单的为它定义一个构造函数和析构函数；随后，我们写一个函数func1，分别定义一个类A和类B的对象a和b：

好了，让我们看看函数func1对应的CPU指令。老规矩，不用关心每条CPU指令的具体含义，仅凭直觉，我们也可以看懂它在做什么。当然，如果你对具体的CPU指令很感兴趣，想死磕一下CPU指令，建议先看一下，相信会对你的理解，大有帮助。

好了，教科书果然没有骗我，很显然！在定义变量a，b的时候，其对应的CPU指令，会自动调用它们各自的构造函数，如上图的红色图框所示；同时，在函数返回时，也会自动的调用它们各自的析构函数，如上图的蓝色图框所示。当然，这些CPU指令，是编译器自动生成的，从源代码上，我们看不出任何的蛛丝马迹。希望这次手动实作，能帮你加深印象，免除一些无感的语法记忆。

但如你所见，这种情况下，即使析构函数，不是虚函数。编译器也可以正确的调用对象a，b对应的析构函数。难道析构函数必须定义成虚函数的说法有误？

让我们再看一个在堆上，动态创建类对象的例子。编写一个简单的函数func2；先new一个类A的对象，并用指针变量a，保存对象的内存首地址；再new一个类B的对象，并用指针变量b，保存对象的内存首地址；随后，分别delete这两个对象a和b：

还记得所讲吗？new的时候，会先调用operator new函数，在堆上申请对象的内存空间；随后，再调用对象的构造函数。

如你所见，这里分别为对象a和对象b，申请了内存空间，如上图中的红色图框所示；随后，又分别调用了它们对应的构造函数，如上图中的蓝色图框所示。再看看delete对应的暗箱操作吧：

不出意外，它们会先调用对象a和对象b的析构函数，如上图中的红色图框所示；然后再调用operator delete函数释放对象a和对象b所占据的内存空间，如上图中的蓝色图框所示。这看上去是不是非常合理呢？那问题来了，既然编译器可以正确调用对象a，b的析构函数，那析构函数，必须是虚函数的真正用意何在呢？

好了，是该面对真正的问题了！写一个简单的函数func3，为了突出重点，我们只使用new产生一个类B的对象，但不同于刚才的函数func2，这次我们利用C++的多态特性，用一个基类A的指针型变量，也就是变量b，来存放这个对象的内存首地址；最后跟func2一样，我们使用delete释放这个对象：

发现问题了吗？new操作，会正确的申请一个类B，需要占据的内存空间，也能正确的调用类B对应的构造函数，如上图中的红色图框所示。但delete操作，并没有调用类B的析构函数，相反，它居然调用了类A的析构函数，这显然是张冠李戴了，如上图中的蓝色图框所示。

请不要苛责编译器的失误，要知道在那个时候，人工智能可没有今天这么发达，编译器只会根据delete的指针类型，静态的决定：调用哪个类的析构函数。也就是所谓的：静态绑定，例如函数func1和func2也是如此，而且这在很多情况下也是合理的。

但显然，如果跟多态搭配使用的话，仅依据指针类型，来断定析构函数的调用，就很容易张冠李戴。很遗憾，编译器并不能正确的推导出指针变量b，所指向的对象的真实类型，而是给了一个折中的方案：动态绑定。但代价是：需要程序员手动的为析构函数加一个关键字：virtual

这时我们再看看CPU指令，会发生什么变化。如你所见，编译器为类A和类B分别建立了虚函数表，如上图中的蓝色图框所示。并在其中分别存放了类A和类B的析构函数的内存首地址。如所说，为每一个类建立一个虚函数列表，可以保证在未来调用虚函数的时候，职责分明，井水不犯河水。

让我们再看看delete对应的CPU指令，看上去复杂了不少，如上图中的红色图框所示。已经很难猜出它们的真实含义了，具体的分析请看上个章节。这里只说结论：前3条指令，是在查阅刚才的虚函数列表，并找到类B的析构函数的内存地址，随后的2条指令就可以调用类B的析构函数，这样，就不会张冠李戴，德不配位了。

好了，至此析构函数的问题，就说完了。真是大神一句话，阿布跑断腿呀！好在编程知识不是圣经，它们都是可验证的，可证伪的。

03

总结

1. 构造函数和析构函数的调用，不是100%自动完成的。特别是通过new生成的对象，需要手动编写delete语句，来间接调用析构函数。

2. 基类和派生类相互调用：构造函数、析构函数的顺序，在编译阶段就决定了，掌握这些语法规则，除了可以查阅书籍，也可以查阅一下CPU指令，如你所见，它们并不复杂，甚至更加直观！

3. 析构函数并非必须是虚函数。但在使用多态的设计方法时，如果析构函数不是虚函数的话，在delete类对象的时候，可能出现张冠李戴的情况。如果想给程序加一份保险的话，那么把析构函数设置成虚函数，总是没错的。

4. 那为什么构造函数不需要定义成：虚函数呢？我想应该是没有这个必要！因为往往在生成类对象的时候，都会明确的指出对象的具体类型，所以，对于构造函数，静态绑定就足够了。

04

热点问题

Q1：为什么一些书籍，明文要求“析构函数”必须是虚函数呢？

A1：这是一个好问题！阿布曾经看过一本书（书名忘了），作者的语言十分犀利，对于virtual的意见，是斩钉截铁的Yes！其实yes也挺好，阿布也不用花时间去研究其中的细节；但不知道大家有没有这种想法，越是绝对的权威，越激发人的探索欲。

当然，只从结果上看，yes当然没有什么问题，至少是安全、保险的。虽然没有什么颠覆性的发现，但确实也有所发现，至少virtual的原因，我们是靠自己的双手弄清楚的，我们也可以解释yes的原因，甚至理由更加充分！这种感觉，跟100%接受权威指南是不一样的。

05

系统学习和5折福利

如果喜欢阿布的解读方式，希望系统学习这些编程知识的话，可以考虑看看阿布编写，并有多位微软大佬联袂推荐的

\”编程始于代码，但不止于代码；让我们通过，实现软硬一体，深度探索编程的️禁区\”

C++基类中虚析构函数

C++中基类采用virtual虚析构函数是为了防止内存泄漏。假设派生类中申请了内存空间，需要在析构函数中释放内存；若基类中采用的是非虚析构函数，当删除基类指针指向的派生类对象时就不会触发动态绑定，因而只会调用基类的析构函数，而不会调用派生类的析构函数。那么在这种情况下，派生类中申请的空间就得不到释放从而产生内存泄漏。所以，为了防止这种情况的发生，C++中基类的析构函数应采用virtual虚析构函数。

下面是基类和派生类中都没有虚析构函数的一个实例：

运行结果：

未定义虚析构函数

从运行结果可以看出，当通过基类指针删除派生类对象时，派生类的析构函数根本没有调用，name指针创建之后没有删除，导致内存泄漏。原因时派生类重写了基类析构函数，虽然派生类和基类的析构函数名字不同，但是编译器对析构函数做了特殊处理。在内部，派生类和基类的析构函数名字是一样的。所以当基类的析构函数为非虚函数时，就不能构成多态，基类的析构函数隐藏了派生类的析构函数，所以只能调用基类的析构函数。

下面是基类定义虚析构函数的一个实例：

运行结果：

定义虚析构函数

从运行结果可以看出，定义了虚析构函数后，用一个基类的指针删除一个派生类的对象时，派生类的析构函数也被调用了。原因是当基类析构函数定义为虚函数后，删除对象时会直接调用派生类的析构函数，由于派生类析构时会先调用基类的析构函数，所以就把派生类和继承的基类都析构了。

• 基类的析构函数不加virtual关键字：当基类的析构函数不声明成虚析构函数，派生类继承基类，基类的指针指向派生类时，delete删除基类的指针，只调动基类的析构函数，而不调动派生类的析构函数。
• 基类的析构函数加virtual关键字：当基类的析构函数声明成虚析构函数，派生类继承基类，基类的指针指向派生类时，delete删除基类的指针，先调动派生类的析构函数，再调动基类的析构函数。
• 由于基类的析构函数为虚函数，所以派生类会在所有属性的前面形成虚表，而虚表内部存储的就是基类的虚函数。
• 当delete基类的指针时，由于派生类的析构函数与基类的析构函数构成多态，所以得先调动派生类的析构函数；之所以再调动基类的析构函数，是因为delete的机制所引起的，delete 基类指针所指的空间，要调用基类的析构函数。

C++程序员必须掌握，为什么有些析构函数也要被定义为虚函数？

在阅读C++项目（caffe）源码时，发现不少基类不仅把常规的成员函数定义成虚函数（virtual），也会把析构函数定义为虚函数，结合前面几节的介绍，稍稍思考下，这样做的确是有原因的，本文将结合C++代码实例尝试探讨下。

为什么要把析构函数定义为虚函数？

随便写一段C++代码作为实例，在这个例子中，我们先不把析构函数定义为虚函数：

这段代码的逻辑很简单，无非就是定义了两个类：类 Base 的成员函数 foo() 为虚函数，构造函数和析构函数都是常规函数，此外它还有个 public 的成员变量 buf。类 Child 则公开继承了 Base，因此它可以直接使用 Base::buf——在构造函数中 new 了一段内存，并且在析构函数 delete 掉它。

我们直接使用 Child 实例化一个对象 c，调用 c.foo()，此时得到如下输出：

一切尽在预料中。

虽说对象 c 调用 foo() 的输出完全符合预计，但像上面那样定义类仍然是非常危险的做法。在这一节我们曾讨论过，父类指针可以调用派生类的重写函数，因此下面这两行C++代码也是合法的，请看：

编译这段C++代码完全没有问题，运行也不会报错，输出如下：

可是，从输出信息能够看出，派生类 Child 的析构函数没有被调用，对于本例而言，new 出来的 buf 没有对应的 delete，势必会造成内存泄漏。

要解决所谓的“不安全问题”，其实很简单，按照题目说的做——将基类的析构函数也定义为虚函数就可以了，请看修改后的C++代码：

也即尽在基类 Base 的析构函数前加上 virtual 关键字，其他的所有代码都无需改动。现在再执行下面的这几行C++代码：

输出如下：

显然，此时派生类 Child 的析构函数也会被调用了，内存泄漏的问题被解决了。

C++ 中的 virtual 关键字是非常好用，也是C++程序员必须掌握的关键字，其实，“不安全问题”出现的原因也是简单的：我们在静态类型与动态绑定一节中提到过，基本上只有涉及到 virtual 函数时，才会发生动态绑定，此时通过对象指针（pb）调用的函数由它指向的类（Child）决定，所以此时派生类 Child 的析构函数会被调用。如果基类 Base 的析构函数不是虚函数，那么对象指针（pb）调用的函数由其静态类型（Base）决定，也即调用的其实只是基类 Base 的析构函数而已。

本文作者及来源:Renderbus瑞云渲染农场https://www.renderbus.com