发布于 由admin

为什么虚析构函数是基类的标配？防止子类内存泄露的必修课

各位同学，大家好！

非常荣幸今天能在这里，与大家共同深入探讨C++面向对象编程中一个看似不起眼，实则至关重要的概念——虚析构函数。在我的编程生涯中，我见过太多因为忽略它而导致的内存泄漏、程序崩溃以及难以调试的复杂问题。所以，今天我不是来给大家讲一个简单的语法点，而是要和大家分享C++在多态环境下进行资源管理的一项“必修课”，一个防止子类内存泄漏的“黄金法则”。

我们将从最基础的场景出发，逐步揭示虚析构函数存在的必然性，它的工作原理，以及在实际项目中如何正确地运用它。请大家准备好，我们即将开始一场关于C++对象生命周期管理和多态深层机制的探索之旅。

1. 问题的根源：多态与对象销毁的冲突

首先，我们来设置一个场景。在C++中，多态是其面向对象特性的核心之一。我们经常会通过基类的指针或引用来操作派生类对象。这使得我们能够编写出灵活、可扩展的代码，实现“一个接口，多种实现”的设计哲学。然而，当涉及到这些通过基类指针创建的派生类对象的生命周期管理时，一个潜在的陷阱就出现了。

考虑以下一个简单的类继承体系：

#include <iostream>
#include <vector>
#include <string>

// 基类
class Base {
public:
    Base(const std::string& name = "BaseObject") : name_(name) {
        std::cout << "Base constructor: " << name_ << std::endl;
    }

    ~Base() { // 注意：这里不是虚析构函数
        std::cout << "Base destructor: " << name_ << std::endl;
    }

    virtual void greet() const {
        std::cout << "Hello from Base: " << name_ << std::endl;
    }

protected:
    std::string name_;
};

// 派生类1
class DerivedA : public Base {
public:
    DerivedA(const std::string& name = "DerivedA_Object") : Base(name) {
        std::cout << "DerivedA constructor: " << name_ << std::endl;
        // 假设DerivedA在这里分配了一些特有的资源，比如一块内存
        extra_data_ = new int[100]; 
        std::cout << "DerivedA allocated 100 ints." << std::endl;
    }

    ~DerivedA() { // 派生类有自己的资源需要释放
        delete[] extra_data_;
        std::cout << "DerivedA destructor: " << name_ << " (released 100 ints)" << std::endl;
    }

    void greet() const override {
        std::cout << "Hello from DerivedA: " << name_ << std::endl;
    }

private:
    int* extra_data_; // 派生类特有的资源
};

// 派生类2
class DerivedB : public Base {
public:
    DerivedB(const std::string& name = "DerivedB_Object") : Base(name) {
        std::cout << "DerivedB constructor: " << name_ << std::endl;
        // 假设DerivedB在这里分配了另一个文件句柄资源
        file_handle_ = fopen("temp_file.txt", "w");
        if (file_handle_) {
            std::cout << "DerivedB opened temp_file.txt." << std::endl;
        } else {
            std::cerr << "Error opening temp_file.txt." << std::endl;
        }
    }

    ~DerivedB() { // 派生类有自己的资源需要释放
        if (file_handle_) {
            fclose(file_handle_);
            std::cout << "DerivedB destructor: " << name_ << " (closed temp_file.txt)" << std::endl;
        }
    }

    void greet() const override {
        std::cout << "Hello from DerivedB: " << name_ << std::endl;
    }

private:
    FILE* file_handle_; // 派生类特有的资源
};

// 模拟一个使用多态的函数
void processObjects(std::vector<Base*> objects) {
    for (Base* obj : objects) {
        obj->greet();
    }
    // 这里是关键：我们通过基类指针删除对象
    std::cout << "n--- Deleting objects via Base pointers ---n";
    for (Base* obj : objects) {
        delete obj; // 问题就发生在这里！
        obj = nullptr; // 良好的编程习惯
    }
}

int main() {
    std::vector<Base*> myObjects;
    myObjects.push_back(new DerivedA("MyDerivedA"));
    myObjects.push_back(new DerivedB("MyDerivedB"));
    myObjects.push_back(new Base("MyBase")); // 也可以有基类对象

    processObjects(myObjects);

    // 理论上，所有资源都应该被正确释放。
    // 但在没有虚析构函数的情况下，DerivedA和DerivedB的特有资源会泄漏。
    std::cout << "n--- End of main ---n";

    return 0;
}

运行这段代码，你会看到如下输出（具体顺序可能略有差异，但关键信息不会变）：

Base constructor: MyDerivedA
DerivedA constructor: MyDerivedA
DerivedA allocated 100 ints.
Base constructor: MyDerivedB
DerivedB constructor: MyDerivedB
DerivedB opened temp_file.txt.
Base constructor: MyBase

Hello from DerivedA: MyDerivedA
Hello from DerivedB: MyDerivedB
Hello from Base: MyBase

--- Deleting objects via Base pointers ---
Base destructor: MyDerivedA
Base destructor: MyDerivedB
Base destructor: MyBase

--- End of main ---

请仔细观察输出结果！当我们通过 processObjects 函数中的 delete obj; 语句删除对象时，尽管 obj 实际上指向的是 DerivedA 或 DerivedB 的实例，但被调用的析构函数只有 Base 类的析构函数。DerivedA 的析构函数和 DerivedB 的析构函数都没有被调用！这意味着 DerivedA 中分配的 extra_data_ 数组和 DerivedB 中打开的 file_handle_ 都没有被释放/关闭。这就是典型的内存泄漏和资源泄漏。

为什么会这样？这就是因为在C++中，当通过基类指针调用析构函数时，如果基类的析构函数不是 virtual 的，那么编译器会执行所谓的“静态绑定”（或“早期绑定”）。它仅仅根据指针的静态类型（在这里是 Base*）来决定调用哪个析构函数，而不会考虑指针实际指向的对象的动态类型。

这个现象是危险的，因为它破坏了面向对象设计中资源管理的完整性。派生类往往会拥有基类所不具备的特有资源，这些资源需要在派生类的析构函数中进行清理。如果派生类的析构函数未能被调用，这些资源将永远不会被释放，直到程序结束，造成内存和资源浪费。

2. C++对象销毁的机制：静态绑定与动态绑定

为了更好地理解虚析构函数的作用，我们有必要回顾一下C++中对象销毁和函数调用的基本机制。

2.1 构造与析构的顺序

当一个派生类对象被创建时，构造函数的调用顺序是从基类到派生类。例如，DerivedA 对象的构造顺序是 Base 构造函数 -> DerivedA 构造函数。

销毁时，这个顺序是相反的。析构函数的调用顺序是从派生类到基类。例如，一个 DerivedA 对象被销毁时，正常的析构顺序应该是 DerivedA 析构函数 -> Base 析构函数。这种顺序保证了派生类可以先清理自己的特有资源，然后再让基类清理其基础资源。

2.2 函数调用与绑定

在C++中，成员函数的调用可以分为两种绑定方式：

  • 静态绑定 (Static Binding / Early Binding)：在编译时就确定了要调用的函数版本。这是C++默认的行为，对于非虚函数而言。编译器根据指针或引用的静态类型来决定调用哪个函数。
  • 动态绑定 (Dynamic Binding / Late Binding)：在运行时才确定要调用的函数版本。这是通过 virtual 关键字实现的。当通过基类指针或引用调用虚函数时，系统会根据指针或引用实际指向的对象的动态类型来决定调用哪个函数。

对于我们之前的例子，greet() 函数是 virtual 的，所以当 obj->greet() 被调用时，即使 obj 是 Base* 类型，也会正确调用 DerivedA::greet() 或 DerivedB::greet()。然而，析构函数 ~Base() 却不是 virtual 的，因此 delete obj; 语句导致了静态绑定，只调用了 Base::~Base()。

3. 救星驾到：虚析构函数 (Virtual Destructor)

现在，我们知道问题所在了。要解决静态绑定带来的析构问题，我们需要让析构函数也能够进行动态绑定。C++为此提供了 virtual 关键字。

我们只需要在基类的析构函数前加上 virtual 关键字，就可以将它变为一个虚析构函数。派生类的析构函数会自动变成虚函数（即使不显式声明 virtual 关键字，但为了代码清晰和可读性，一些风格指南也建议显式声明）。

让我们修改 Base 类，使其析构函数变为虚析构函数：

#include <iostream>
#include <vector>
#include <string>
#include <cstdio> // For FILE* and fopen/fclose

// 基类
class Base {
public:
    Base(const std::string& name = "BaseObject") : name_(name) {
        std::cout << "Base constructor: " << name_ << std::endl;
    }

    // 关键改变：基类的析构函数现在是虚函数了！
    virtual ~Base() { 
        std::cout << "Base destructor: " << name_ << std::endl;
    }

    virtual void greet() const {
        std::cout << "Hello from Base: " << name_ << std::endl;
    }

protected:
    std::string name_;
};

// 派生类1 (保持不变，因为派生类的析构函数会自动变为虚函数)
class DerivedA : public Base {
public:
    DerivedA(const std::string& name = "DerivedA_Object") : Base(name) {
        std::cout << "DerivedA constructor: " << name_ << std::endl;
        extra_data_ = new int[100]; 
        std::cout << "DerivedA allocated 100 ints." << std::endl;
    }

    // 即使不写 virtual，它也是虚函数，但显式写出有助于理解
    ~DerivedA() override { // C++11 引入的 override 关键字可以帮助检查是否正确覆盖
        delete[] extra_data_;
        std::cout << "DerivedA destructor: " << name_ << " (released 100 ints)" << std::endl;
    }

    void greet() const override {
        std::cout << "Hello from DerivedA: " << name_ << std::endl;
    }

private:
    int* extra_data_; 
};

// 派生类2 (保持不变)
class DerivedB : public Base {
public:
    DerivedB(const std::string& name = "DerivedB_Object") : Base(name) {
        std::cout << "DerivedB constructor: " << name_ << std::endl;
        file_handle_ = fopen("temp_file.txt", "w");
        if (file_handle_) {
            std::cout << "DerivedB opened temp_file.txt." << std::endl;
        } else {
            std::cerr << "Error opening temp_file.txt." << std::endl;
        }
    }

    ~DerivedB() override {
        if (file_handle_) {
            fclose(file_handle_);
            std::cout << "DerivedB destructor: " << name_ << " (closed temp_file.txt)" << std::endl;
        }
    }

    void greet() const override {
        std::cout << "Hello from DerivedB: " << name_ << std::endl;
    }

private:
    FILE* file_handle_; 
};

// 模拟一个使用多态的函数 (与之前相同)
void processObjects(std::vector<Base*> objects) {
    for (Base* obj : objects) {
        obj->greet();
    }
    std::cout << "n--- Deleting objects via Base pointers ---n";
    for (Base* obj : objects) {
        delete obj; 
        obj = nullptr; 
    }
}

int main() {
    std::vector<Base*> myObjects;
    myObjects.push_back(new DerivedA("MyDerivedA_Virtual"));
    myObjects.push_back(new DerivedB("MyDerivedB_Virtual"));
    myObjects.push_back(new Base("MyBase_Virtual")); 

    processObjects(myObjects);

    std::cout << "n--- End of main ---n";

    return 0;
}

再次运行这段代码，请看输出：

Base constructor: MyDerivedA_Virtual
DerivedA constructor: MyDerivedA_Virtual
DerivedA allocated 100 ints.
Base constructor: MyDerivedB_Virtual
DerivedB constructor: MyDerivedB_Virtual
DerivedB opened temp_file.txt.
Base constructor: MyBase_Virtual

Hello from DerivedA: MyDerivedA_Virtual
Hello from DerivedB: MyDerivedB_Virtual
Hello from Base: MyBase_Virtual

--- Deleting objects via Base pointers ---
DerivedA destructor: MyDerivedA_Virtual (released 100 ints)
Base destructor: MyDerivedA_Virtual
DerivedB destructor: MyDerivedB_Virtual (closed temp_file.txt)
Base destructor: MyDerivedB_Virtual
Base destructor: MyBase_Virtual

--- End of main ---

奇迹发生了！现在，当我们通过 Base* 指针 delete 派生类对象时，程序正确地调用了派生类的析构函数，然后才调用基类的析构函数。DerivedA 的 extra_data_ 被释放了，DerivedB 的 file_handle_ 也被关闭了。内存泄漏和资源泄漏的问题迎刃而解！

这就是虚析构函数的魔力。它确保了在多态环境中，对象的完整销毁过程能够正确执行，从而避免了资源泄漏。

3.1 虚析构函数的工作原理简述

虚析构函数的工作原理与虚函数调用机制是相同的，都依赖于虚函数表 (vtable) 和 虚指针 (vptr)。

  1. 当一个类包含虚函数（包括虚析构函数）时，编译器会为该类创建一个虚函数表。这个表中存储着该类所有虚函数的地址。
  2. 每个包含虚函数的对象都会在其内存布局中多一个隐藏的指针，称为虚指针 (vptr)。这个 vptr 在对象构造时被初始化，指向对应类的虚函数表。
  3. 当通过基类指针或引用调用一个虚函数时，C++运行时系统会使用 vptr 找到对象的虚函数表，然后根据虚函数在表中的偏移量，调用正确的函数版本。
  4. 对于虚析构函数，当 delete 一个基类指针时，运行时系统会根据该指针实际指向的对象的 vptr，找到正确的派生类析构函数，并从派生类到基类依次调用析构链。

4. 何时使用虚析构函数：基类的标配原则

现在我们明白了虚析构函数的重要性，那么问题来了：是不是所有类都需要虚析构函数？答案是否定的，但有一个黄金法则：

如果一个类打算被用作多态基类，并且可能会通过基类指针或引用来删除派生类对象，那么它的析构函数就必须是虚的。

我们可以将这个原则细化为以下几点：

4.1 黄金法则：如果类有任何虚函数，它的析构函数就应该是虚的。

这是因为如果一个类有虚函数，它很可能被设计为一个多态基类。这意味着你可能会通过基类指针来操作派生类对象。在这种情况下，如果你忘记将析构函数声明为虚函数，那么当你通过基类指针删除派生类对象时，就会发生我们之前演示的内存泄漏问题。这是一个非常强烈的信号，表明该类需要虚析构函数。

class BaseWithVirtualFunc {
public:
    BaseWithVirtualFunc() { /* ... */ }
    virtual ~BaseWithVirtualFunc() { // 必须是虚的
        std::cout << "BaseWithVirtualFunc destructor called.n";
    }
    virtual void doSomething() { /* ... */ }
};

class DerivedFromVirtualFunc : public BaseWithVirtualFunc {
public:
    DerivedFromVirtualFunc() { /* ... */ }
    ~DerivedFromVirtualFunc() override { // 自动是虚的
        std::cout << "DerivedFromVirtualFunc destructor called.n";
    }
    void doSomething() override { /* ... */ }
};

// 使用场景：
BaseWithVirtualFunc* ptr = new DerivedFromVirtualFunc();
ptr->doSomething(); // 多态行为正确
delete ptr;         // 虚析构函数确保正确销毁

4.2 如果类不包含任何虚函数，但你依然打算将它用作多态基类。

虽然这种情况不常见，但如果一个类没有虚函数，但你确实打算通过基类指针来删除它的派生类对象，那么你仍然需要将基类的析构函数声明为虚函数。

class BaseNoOtherVirtual {
public:
    BaseNoOtherVirtual() { /* ... */ }
    virtual ~BaseNoOtherVirtual() { // 即使没有其他虚函数，如果会通过基类指针删除，也需要是虚的
        std::cout << "BaseNoOtherVirtual destructor called.n";
    }
    // 没有其他虚函数
};

class DerivedFromNoOtherVirtual : public BaseNoOtherVirtual {
public:
    DerivedFromNoOtherVirtual() { /* ... */ }
    ~DerivedFromNoOtherVirtual() override {
        std::cout << "DerivedFromNoOtherVirtual destructor called.n";
    }
    // 没有其他虚函数
};

// 使用场景：
BaseNoOtherVirtual* ptr = new DerivedFromNoOtherVirtual();
delete ptr; // 虚析构函数确保正确销毁

这种情况比较少见，因为如果一个基类没有任何虚函数，通常意味着它不被设计为多态基类。但如果出于某种特殊的设计考虑，你确实需要通过基类指针删除派生类，那么虚析构函数是必须的。

4.3 何时不需要虚析构函数？

如果一个类不是基类，或者它作为基类但永远不会通过基类指针或引用被删除，那么它的析构函数就不需要是虚的。

  • 非基类：对于普通的、独立的类，没有继承关系，虚析构函数没有任何意义。
  • 不作为多态基类的基类：如果一个类是基类，但你明确知道不会通过基类指针来删除派生类对象（例如，你总是通过派生类指针删除，或者使用 std::unique_ptr<DerivedType>），那么从技术上讲，你不需要虚析构函数。然而，这是一种脆弱的设计决策，因为它依赖于对未来使用的严格限制。一旦有人不小心通过基类指针 delete 了，问题就会出现。所以，除非你对你的设计有绝对的控制和保证，否则最好遵循“如果作为基类，且有任何虚函数，则析构函数为虚”的原则。
  • 性能考量（通常微不足道）：虚函数会引入一点点运行时开销（vptr和vtable），以及每个对象会增加一个指针大小的内存开销。对于性能极端敏感的系统，如果你能百分之百确定不会发生多态删除，可以避免虚析构函数。但在绝大多数现代应用中，这点开销是完全可以接受的，安全性远大于这点微小性能牺牲。

4.4 总结何时使用虚析构函数

场景 需要虚析构函数？ 理由 最佳实践
类有任何虚函数 是 这表明该类旨在作为多态基类。通过基类指针删除派生类对象是常见模式，此时需要确保派生类析构函数被调用。 黄金法则：如果类有虚函数，析构函数就应该是虚的。
类作为基类，且可能通过基类指针删除派生类对象 是 即使没有其他虚函数，如果预期会发生多态删除，也必须是虚的，以避免资源泄漏。 强烈建议将析构函数声明为虚函数。
类作为基类，但明确保证不会通过基类指针删除派生类对象 否 理论上不需要，但这是一个脆弱的假设。一旦未来代码改变，这个假设可能被打破，导致隐蔽的bug。 谨慎使用。除非有非常严格的理由（如极度追求性能且对对象生命周期有绝对控制），否则仍然建议使用虚析构函数，以提高代码的健壮性和安全性。或者考虑将基类的析构函数声明为 protected 非虚析构函数，这样可以阻止直接通过基类指针 delete 对象，但允许派生类调用基类析构。
类不是基类 (即没有派生类，或不作为基类使用) 否 虚析构函数会带来微小的性能和内存开销，对于非多态类来说没有益处。 保持析构函数为非虚。
final 类 否 final 关键字表示该类不能被继承。既然不能被继承，它就永远不会作为多态基类，因此虚析构函数没有意义。 保持析构函数为非虚。

5. 纯虚析构函数：抽象基类的特殊情况

有时候，我们希望一个基类是抽象的，即不能直接实例化。这通常通过在类中声明至少一个纯虚函数来实现。但如果一个抽象基类没有其他虚函数，而你又希望它能被多态地删除，那该怎么办呢？这时就需要用到纯虚析构函数。

一个纯虚析构函数的声明方式是 virtual ~Base() = 0;。这使得 Base 类成为一个抽象类，不能被直接实例化。

然而，与普通纯虚函数不同的是，即使析构函数是纯虚的，它也必须提供一个定义。这是因为派生类的析构函数在执行完毕后，仍然需要调用其基类的析构函数（从派生到基的析构链）。如果纯虚析构函数没有定义，那么在链接阶段就会报错。

#include <iostream>
#include <string>

// 抽象基类，带有纯虚析构函数
class AbstractBase {
public:
    AbstractBase(const std::string& name = "AbstractBaseObj") : name_(name) {
        std::cout << "AbstractBase constructor: " << name_ << std::endl;
    }

    // 纯虚析构函数，使得 AbstractBase 成为抽象类
    virtual ~AbstractBase() = 0; 

    virtual void pureVirtualFunc() const = 0; // 其他纯虚函数
    virtual void commonFunc() const {
        std::cout << "AbstractBase commonFunc: " << name_ << std::endl;
    }

protected:
    std::string name_;
};

// 纯虚析构函数必须提供定义！
AbstractBase::~AbstractBase() {
    std::cout << "AbstractBase destructor: " << name_ << std::endl;
}

class ConcreteDerived : public AbstractBase {
public:
    ConcreteDerived(const std::string& name = "ConcreteDerivedObj") : AbstractBase(name) {
        std::cout << "ConcreteDerived constructor: " << name_ << std::endl;
        resource_ = new int(100);
        std::cout << "ConcreteDerived allocated resource." << std::endl;
    }

    ~ConcreteDerived() override {
        delete resource_;
        std::cout << "ConcreteDerived destructor: " << name_ << " (released resource)" << std::endl;
    }

    void pureVirtualFunc() const override {
        std::cout << "ConcreteDerived implementing pureVirtualFunc: " << name_ << std::endl;
    }

private:
    int* resource_;
};

int main() {
    // AbstractBase* obj = new AbstractBase(); // 编译错误：不能实例化抽象类

    AbstractBase* ptr = new ConcreteDerived("MyConcreteObject");
    ptr->pureVirtualFunc();
    ptr->commonFunc();

    std::cout << "n--- Deleting object via AbstractBase pointer ---n";
    delete ptr; // 确保正确调用 ConcreteDerived 的析构函数

    std::cout << "n--- End of main ---n";

    return 0;
}

输出：

AbstractBase constructor: MyConcreteObject
ConcreteDerived constructor: MyConcreteObject
ConcreteDerived allocated resource.
ConcreteDerived implementing pureVirtualFunc: MyConcreteObject
AbstractBase commonFunc: MyConcreteObject

--- Deleting object via AbstractBase pointer ---
ConcreteDerived destructor: MyConcreteObject (released resource)
AbstractBase destructor: MyConcreteObject

--- End of main ---

可以看到，即使析构函数是纯虚的，只要提供了定义，并且基类的析构函数是虚的，那么多态删除就能正常工作。纯虚析构函数的主要作用是强制一个类成为抽象类，同时确保其派生类在销毁时能正确地调用基类的析构部分。

6. 虚析构函数与C++的“三/五/零法则”

虚析构函数与C++中的“三/五/零法则” (Rule of Three/Five/Zero) 密切相关。这个法则指导我们如何正确地管理类中拥有的资源。

  • 三法则 (Rule of Three)：如果一个类需要自定义析构函数 (~ClassName())、拷贝构造函数 (ClassName(const ClassName&) ) 或拷贝赋值运算符 (ClassName& operator=(const ClassName&)) 中的任何一个，那么它很可能需要定义所有三个。这是因为这三个函数都涉及对类所管理资源的正确处理。如果你的类需要一个虚析构函数（因为它是多态基类且管理资源），那么它很可能也需要自定义拷贝构造和拷贝赋值。
  • 五法则 (Rule of Five)：随着C++11引入了移动语义，三法则扩展到了五法则，增加了移动构造函数 (ClassName(ClassName&&)) 和移动赋值运算符 (ClassName& operator=(ClassName&&))。如果你的类需要自定义析构函数，那么很可能也需要定义这四个特殊的成员函数，以实现完整的资源管理。
  • 零法则 (Rule of Zero)：现代C++的理想状态。如果你的类不拥有任何原始资源（例如，它只包含 std::string、std::vector、std::unique_ptr 等标准库类型，这些类型本身已经实现了正确的资源管理），那么你不需要手动定义任何析构函数、拷贝/移动构造函数或赋值运算符。编译器生成的默认版本通常就足够了。零法则的精髓是“让RAII容器管理资源”。

虚析构函数与这些法则的关系：

如果你的基类需要一个虚析构函数，这通常意味着它或它的派生类会管理一些资源。在这种情况下，你就需要特别关注拷贝构造、拷贝赋值和移动语义，以确保资源的深拷贝或正确转移，避免双重释放或泄漏。虚析构函数是确保资源在对象生命周期结束时被正确清理的关键一环，而拷贝/移动操作则是确保资源在对象生命周期中被正确复制或转移的关键。

7. 虚析构函数与智能指针

智能指针是现代C++中管理动态内存的利器，如 std::unique_ptr 和 std::shared_ptr。它们极大地简化了内存管理，并减少了内存泄漏的风险。那么，智能指针是否需要虚析构函数呢？

答案是：智能指针本身不依赖虚析构函数来实现其核心功能，但它们所管理的底层对象（即你 new 出来的对象）仍然需要虚析构函数，以确保在多态删除时派生类析构函数被调用。

智能指针的析构函数会调用其内部持有的裸指针的 delete 操作。例如，std::unique_ptr<Base> p(new Derived()); 当 p 超出作用域时，p 的析构函数会执行 delete p.get();。这里的 delete p.get(); 行为与我们手动 delete base_ptr; 的行为完全相同。

所以，如果 Base 的析构函数不是 virtual 的，即使使用 std::unique_ptr<Base> 或 std::shared_ptr<Base> 来管理 Derived 对象，仍然会发生内存泄漏。

#include <iostream>
#include <memory> // For std::unique_ptr, std::shared_ptr
#include <string>

// 基类 (故意不加 virtual 析构函数来演示问题)
class BaseNoVirtualDtor {
public:
    BaseNoVirtualDtor(const std::string& name = "BaseNoVirtualDtor") : name_(name) {
        std::cout << "BaseNoVirtualDtor constructor: " << name_ << std::endl;
    }
    ~BaseNoVirtualDtor() { // 非虚析构函数
        std::cout << "BaseNoVirtualDtor destructor: " << name_ << std::endl;
    }
    virtual void print() const {
        std::cout << "BaseNoVirtualDtor print: " << name_ << std::endl;
    }
protected:
    std::string name_;
};

// 派生类
class DerivedWithResource : public BaseNoVirtualDtor {
public:
    DerivedWithResource(const std::string& name = "DerivedWithResource") : BaseNoVirtualDtor(name) {
        std::cout << "DerivedWithResource constructor: " << name_ << std::endl;
        data_ = new int[10]; // 模拟资源分配
        std::cout << "DerivedWithResource allocated 10 ints." << std::endl;
    }
    ~DerivedWithResource() override { // 注意这里 override 只是为了清晰，实际上它不会被调用
        delete[] data_;
        std::cout << "DerivedWithResource destructor: " << name_ << " (released 10 ints)" << std::endl;
    }
    void print() const override {
        std::cout << "DerivedWithResource print: " << name_ << std::endl;
    }
private:
    int* data_;
};

// 基类 (带有 virtual 析构函数来演示解决方案)
class BaseWithVirtualDtor {
public:
    BaseWithVirtualDtor(const std::string& name = "BaseWithVirtualDtor") : name_(name) {
        std::cout << "BaseWithVirtualDtor constructor: " << name_ << std::endl;
    }
    virtual ~BaseWithVirtualDtor() { // 虚析构函数
        std::cout << "BaseWithVirtualDtor destructor: " << name_ << std::endl;
    }
    virtual void print() const {
        std::cout << "BaseWithVirtualDtor print: " << name_ << std::endl;
    }
protected:
    std::string name_;
};

// 派生类 (与上面相同，只是继承自 BaseWithVirtualDtor)
class DerivedWithResource_Fixed : public BaseWithVirtualDtor {
public:
    DerivedWithResource_Fixed(const std::string& name = "DerivedWithResource_Fixed") : BaseWithVirtualDtor(name) {
        std::cout << "DerivedWithResource_Fixed constructor: " << name_ << std::endl;
        data_ = new int[10]; // 模拟资源分配
        std::cout << "DerivedWithResource_Fixed allocated 10 ints." << std::endl;
    }
    ~DerivedWithResource_Fixed() override { // 确保被调用
        delete[] data_;
        std::cout << "DerivedWithResource_Fixed destructor: " << name_ << " (released 10 ints)" << std::endl;
    }
    void print() const override {
        std::cout << "DerivedWithResource_Fixed print: " << name_ << std::endl;
    }
private:
    int* data_;
};

int main() {
    std::cout << "--- Scenario 1: std::unique_ptr with non-virtual destructor ---n";
    {
        std::unique_ptr<BaseNoVirtualDtor> p1 = std::make_unique<DerivedWithResource>("LeakObject");
        p1->print();
    } // p1 超出作用域，析构
    std::cout << "Notice: DerivedWithResource destructor was NOT called, memory leak!nn";

    std::cout << "--- Scenario 2: std::unique_ptr with virtual destructor ---n";
    {
        std::unique_ptr<BaseWithVirtualDtor> p2 = std::make_unique<DerivedWithResource_Fixed>("NoLeakObject");
        p2->print();
    } // p2 超出作用域，析构
    std::cout << "Notice: DerivedWithResource_Fixed destructor WAS called, no leak!nn";

    std::cout << "--- Scenario 3: std::shared_ptr with non-virtual destructor ---n";
    {
        std::shared_ptr<BaseNoVirtualDtor> p3 = std::make_shared<DerivedWithResource>("SharedLeakObject");
        p3->print();
    } // p3 超出作用域，析构
    std::cout << "Notice: DerivedWithResource destructor was NOT called, memory leak!nn";

    std::cout << "--- Scenario 4: std::shared_ptr with virtual destructor ---n";
    {
        std::shared_ptr<BaseWithVirtualDtor> p4 = std::make_shared<DerivedWithResource_Fixed>("SharedNoLeakObject");
        p4->print();
    } // p4 超出作用域，析构
    std::cout << "Notice: DerivedWithResource_Fixed destructor WAS called, no leak!nn";

    std::cout << "--- End of main ---n";
    return 0;
}

输出：

--- Scenario 1: std::unique_ptr with non-virtual destructor ---
BaseNoVirtualDtor constructor: LeakObject
DerivedWithResource constructor: LeakObject
DerivedWithResource allocated 10 ints.
DerivedWithResource print: LeakObject
BaseNoVirtualDtor destructor: LeakObject
Notice: DerivedWithResource destructor was NOT called, memory leak!

--- Scenario 2: std::unique_ptr with virtual destructor ---
BaseWithVirtualDtor constructor: NoLeakObject
DerivedWithResource_Fixed constructor: NoLeakObject
DerivedWithResource_Fixed allocated 10 ints.
DerivedWithResource_Fixed print: NoLeakObject
DerivedWithResource_Fixed destructor: NoLeakObject (released 10 ints)
BaseWithVirtualDtor destructor: NoLeakObject
Notice: DerivedWithResource_Fixed destructor WAS called, no leak!

--- Scenario 3: std::shared_ptr with non-virtual destructor ---
BaseNoVirtualDtor constructor: SharedLeakObject
DerivedWithResource constructor: SharedLeakObject
DerivedWithResource allocated 10 ints.
DerivedWithResource print: SharedLeakObject
BaseNoVirtualDtor destructor: SharedLeakObject
Notice: DerivedWithResource destructor was NOT called, memory leak!

--- Scenario 4: std::shared_ptr with virtual destructor ---
BaseWithVirtualDtor constructor: SharedNoLeakObject
DerivedWithResource_Fixed constructor: SharedNoLeakObject
DerivedWithResource_Fixed allocated 10 ints.
DerivedWithResource_Fixed print: SharedNoLeakObject
DerivedWithResource_Fixed destructor: SharedNoLeakObject (released 10 ints)
BaseWithVirtualDtor destructor: SharedNoLeakObject
Notice: DerivedWithResource_Fixed destructor WAS called, no leak!

--- End of main ---

这个例子清楚地表明，即使使用了智能指针，虚析构函数在多态场景下依然是不可或缺的。智能指针只是帮你自动调用 delete，但 delete 的行为（静态绑定还是动态绑定）仍然由被删除对象的基类析构函数是否为 virtual 所决定。

8. 常见误区与高级考量

8.1 误区：在派生类中声明 virtual 析构函数就够了

这是一个常见的误区。virtual 关键字只有在基类中声明时才有效。如果基类的析构函数不是 virtual 的，那么无论派生类的析构函数是否声明 virtual (或 override)，它都不会成为虚函数，因为基类中没有对应的虚函数可以被覆盖。动态绑定只发生在虚函数链的起点。

class BaseIncorrect {
public:
    ~BaseIncorrect() { // 非虚析构函数
        std::cout << "BaseIncorrect destructor.n";
    }
};

class DerivedIncorrect : public BaseIncorrect {
public:
    // 尽管这里写了 override，但它不会是虚的，因为 BaseIncorrect 没有虚析构函数
    ~DerivedIncorrect() override { 
        std::cout << "DerivedIncorrect destructor.n";
    }
};

// ...
BaseIncorrect* ptr = new DerivedIncorrect();
delete ptr; // 只会调用 BaseIncorrect::~BaseIncorrect()

8.2 误区：所有析构函数都应该是 virtual 的

我们前面已经讨论过，并非所有析构函数都需要是虚的。如果一个类不作为基类，或者不通过基类指针删除派生类，虚析构函数只会带来微小的开销（对象大小增加一个指针，vtable开销），而没有任何好处。这是对系统资源的轻微浪费。

8.3 将基类析构函数设为 protected 非虚析构函数

这是一种特殊的设计模式，用于阻止通过基类指针直接 delete 对象，但允许派生类正常销毁。 这种做法通常用于那些你希望它们作为基类，但又不希望被多态删除的类。

class BaseProtectedDtor {
protected: // 析构函数是 protected
    ~BaseProtectedDtor() {
        std::cout << "BaseProtectedDtor destructor.n";
    }
public:
    // 其他成员...
};

class DerivedFromProtectedDtor : public BaseProtectedDtor {
public:
    ~DerivedFromProtectedDtor() { // 派生类析构函数
        std::cout << "DerivedFromProtectedDtor destructor.n";
    }
};

int main() {
    // BaseProtectedDtor* p = new DerivedFromProtectedDtor();
    // delete p; // 编译错误！因为BaseProtectedDtor的析构函数是protected，无法通过BaseProtectedDtor*删除

    DerivedFromProtectedDtor* dp = new DerivedFromProtectedDtor();
    delete dp; // 正常工作，先调用DerivedFromProtectedDtor析构，再调用BaseProtectedDtor析构
    return 0;
}

这种方式保证了对象总是通过其确切的派生类类型指针来删除，从而避免了虚析构函数的需求。但请注意，这限制了多态删除的能力，所以只适用于特定场景。

9. 总结与展望

通过今天的深入探讨，我们已经详细了解了虚析构函数在C++多态环境中的核心作用。它不仅仅是一个简单的语法点，更是确保对象生命周期完整性、防止内存和资源泄漏的关键机制。

我们从一个典型的内存泄漏案例出发，逐步揭示了静态绑定在对象销毁时带来的陷阱。随后，我们引入了虚析构函数，并通过代码示例证明了其解决问题的有效性。我们探讨了虚析构函数的工作原理——基于虚函数表和虚指针的动态绑定机制，并总结了“如果类有任何虚函数，它的析构函数就应该是虚的”这一黄金法则。

此外，我们还涉及了纯虚析构函数的特殊用法，以及虚析构函数与C++“三/五/零法则”和智能指针的紧密联系。最后，我们指出了几个常见的误区和一些高级的设计考量。

正确地使用虚析构函数是C++面向对象编程中不可或缺的实践。它让我们的多态设计更加健壮、安全。作为编程专家，我们不仅要知其然，更要知其所以然。希望今天的讲座能帮助大家彻底掌握这一“基类的标配”，让我们的代码远离内存泄漏的困扰，构建出更加可靠、高效的C++应用程序。谢谢大家！

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注