虚析构函数

不使用虚析构函数，可能导致资源泄漏

面试官： 我们知道，析构函数是在对象生命周期结束时，用于清理资源的特殊成员函数。在 C++ 的继承体系中，我们有时需要把基类的析构函数声明为虚函数 (virtual)。

请看下面这段代码，它可能会导致一个非常严重的问题：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>

class Base {
public:
    Base() { std::cout << "Base Created\n"; }
    // 注意：析构函数不是虚函数
    ~Base() { std::cout << "Base Destroyed\n"; }
};

class Derived : public Base {
public:
    Derived() { std::cout << "Derived Created\n"; }
    ~Derived() { std::cout << "Derived Destroyed\n"; }
};

int main() {
    Base* p = new Derived(); // 基类指针指向派生类对象
    
    delete p; // 问题就出在这里！
    
    return 0;
}

我的问题是：

你预测一下，上面这段代码的输出会是什么？
这个输出结果揭示了什么样的严重问题？
这个问题的根本原因是什么？（即，delete p; 这行代码，编译器是如何决定调用哪个析构函数的？）

回答：

上面代码的输出会是 Base Created Derived Created 和 Base Destroyed.
这说明，在构造时，我们调用了基类的构造函数和派生类的构造函数，但是在析构时，我们只调用的基类的析构函数。这两者的不匹配，可能导致分配的资源没有被清理干净。
根本原因：基类的析构函数不是虚函数，因此 delete p 直接调用了基类的析构函数，而不是派生类的析构函数。

面试官 (总结与深化): 你说的完全正确。我来帮你把这个过程再详细地梳理一遍。

问题的完整流程：

构造过程 (正常)：
- new Derived() 会先调用基类 Base 的构造函数，再调用派生类 Derived 的构造函数。
- 所以，构造时的输出是：
```
Base Created
Derived Created
```
析构过程 (出问题的部分)：
- 当编译器看到 delete p;，它会检查 p 的静态类型。p 的类型是 Base*。
- 然后，它检查 Base 类的析构函数是否为 virtual。
- 答案是：不是。
- 因此，编译器执行静态绑定 (Static Binding)。它在编译时就硬编码了调用 Base::~Base() 的指令。
- 结果：程序在运行时，只会调用 Base 的析构函数。Derived::~Derived() 完全被跳过了！

导致的严重后果 (正如你所说):

资源泄漏 (Resource Leak)：如果 Derived 类在它的构造函数中申请了任何资源（比如 new 了一块内存、打开了一个文件、建立了一个网络连接），那么这些资源将永远没有机会在 ~Derived() 中被释放。这是 C++ 中最严重的 bug 之一。

你对这个问题的成因和后果，已经理解得非常透彻了。

虚析构函数

面试官 (继续提问): 好的，既然我们知道了问题所在。那么，请你修改 Base 类，只需要增加一个关键字，就能让上面那段 main 函数的代码正确工作（即正确地调用派生类的析构函数）。

修改后，正确的输出应该是什么样的？这个关键字是如何让编译器改变它的行为的？

回答：

我们只需要设定基类中的析构函数为虚函数，即：在基类的析构函数前加上 virtual 关键字。

1
2
3
4
5
class Base {
public:
    Base() { std::cout << "Base Created\n"; }
    virtual ~Base() { std::cout << "Base Destroyed\n"; } // <- 修改了这一行！
};

这个修改，让编译器了解到基类的析构函数是一个虚函数，因此它会在程序运行时，根据指针所指的实际类型，来动态绑定所调用的析构函数。在我们的例子中，它就会调用到派生类 Derived 的析构函数啦！

面试官 (总结与肯定): 你说的完全正确。

加上 virtual 之后，delete p; 的行为就变成了：

编译器看到 delete p;，检查 p 的静态类型是 Base*。
它检查 Base 类的析构函数，发现它是 virtual 的。
因此，编译器执行动态绑定 (Dynamic Binding)。它不再硬编码调用哪个析构函数，而是生成一段代码，用于在运行时查找正确的析构函数。
在运行时，程序通过 p 指针找到它所指向的 Derived 对象，读取该对象的 v-ptr，找到 Derived 类的 v-table，并从中找到指向 Derived::~Derived() 的函数指针。
Derived 的析构函数 ~Derived() 被调用。
一个非常重要的规则是：当一个派生类的析构函数执行完毕后，它会自动、隐式地调用其基类的析构函数。
因此，Base 的析构函数 ~Base() 也会被调用。

所以，修改后的正确输出顺序是：

Base Created
Derived Created
Derived Destroyed // 先调用派生类的析构
Base Destroyed  // 再自动调用基类的析构

这个构造（从基类到派生类）和析构（从派生类到基类）的顺序，像一个“叠盘子”和“收盘子”的过程，非常对称和合理。

基类析构函数设计的“黄金法则”

面试官 (最终问题): 好的，你对虚析构函数的原理和用法已经非常清楚了。

最后一个问题，来总结一下这个知识点。在 C++ 中，有一条非常重要的设计准则，被称为 “基类析构函数黄金法则”。你能用自己的话，概括一下这条法则吗？

换句话说，作为一个类的设计者，你在什么情况下，应该总是把析构函数声明为 virtual？有没有例外？

回答：

当一个类存在派生类时，这个类就总是应该把自己的析构函数声明为 virtual；而如果一个类没有派生类，则无需声明自己的析构函数为 virtual。
其实，在大多数情况下，我们不妨都将类的析构函数声明为 virtual。

面试官 (总结与精确化): 你说的完全正确。我们来把这条法则的表述再精确化、更具前瞻性一些。

基类析构函数黄金法则：

只要你的类被设计为“可能”被继承，并且“可能”通过基类指针进行多态操作（特别是 delete），那么你就应该将其析构函数声明为 virtual。

这个表述比“存在派生类时”更具前瞻性。因为当你设计一个基类时，你可能还不知道未来会不会有人来继承它。virtual 析构函数，就是你为这种可能性提供的一个安全保障。

有没有例外？

明确不作为基类使用：如果你能确定你的类永远不会被继承，或者即使被继承，也永远不会有 Base* p = new Derived; delete p; 这样的用法，那么析构函数就不是必须为 virtual 的。
- 比如，你可以将类声明为 final (class MyClass final { ... };)，这就从语法上禁止了继承，那么它的析构函数自然就不需要是 virtual 的了。
STL 容器等值类型：std::vector, std::string 这些类，它们的设计目标是作为值类型来使用，而不是作为多态基类。继承 std::vector 通常是一种错误的设计，因此它们的析构函数也不是虚函数。

反过来思考： 将析构函数声明为 virtual 有什么微小的代价吗？

空间代价：会为类增加一个 v-ptr 的大小（通常是一个指针的大小，4 或 8 字节）。
性能代价：会创建 v-table，虚函数调用比普通函数调用多一次内存寻址，稍微慢一点点。

结论： 在绝大多数情况下，这个微小的代价，相比于“防止资源泄漏”这个巨大的安全收益来说，是完全值得的。因此，在设计一个可能被继承的类时，给它一个虚析构函数，是一个极其廉价且重要的保险。

总结

面试结束

今天我们深入地复习和探讨了虚析构函数这一 C++ 核心概念。

我们理解了不使用虚析构函数在多态删除时会导致的资源泄漏问题。
掌握了 virtual 关键字如何通过动态绑定来解决这个问题。
并最终总结出了“只要一个类可能被用作多态基类，就给它一个虚析构函数”这一黄金法则。

你今天的表现非常出色，对问题的理解和回答都非常到位。这次的学习非常成功！

不使用虚析构函数，可能导致资源泄漏

虚析构函数

基类析构函数设计的“黄金法则”

总结

相关文章