虚析构函数的必要性 ​

面试考点 ​

虚析构函数是 C++ 面试中几乎必问的基础题。面试官考察你是否理解:通过基类指针删除派生类对象时,如果析构函数不是虚的,会导致未定义行为和资源泄漏。

核心概念 ​

当你通过基类指针 delete 一个派生类对象时,编译器需要知道应该调用哪个析构函数。如果基类析构函数不是虚的,编译器只会调用基类的析构函数,派生类的析构函数被跳过,派生类中分配的资源不会被释放。C++ 标准明确规定:如果静态类型和动态类型不同,且静态类型没有虚析构函数,delete 的行为是未定义的。

基本示例 ​

cpp
#include <iostream>
#include <string>
#include <memory>

// ============================
// 示例1:没有虚析构函数的问题
// ============================

class BaseNoVirtual {
public:
    BaseNoVirtual() {
        std::cout << "BaseNoVirtual 构造" << std::endl;
    }
    // 注意:析构函数不是虚的!
    ~BaseNoVirtual() {
        std::cout << "BaseNoVirtual 析构" << std::endl;
    }
};

class DerivedNoVirtual : public BaseNoVirtual {
    int* data_;
public:
    DerivedNoVirtual() : data_(new int[1000]) {
        std::cout << "DerivedNoVirtual 构造(分配了内存)" << std::endl;
    }
    ~DerivedNoVirtual() {
        delete[] data_;
        std::cout << "DerivedNoVirtual 析构(释放了内存)" << std::endl;
    }
};

void no_virtual_dtor_problem() {
    // 通过基类指针删除派生类对象
    BaseNoVirtual* ptr = new DerivedNoVirtual();
    delete ptr;
    // 输出:
    //   BaseNoVirtual 构造
    //   DerivedNoVirtual 构造(分配了内存)
    //   BaseNoVirtual 析构
    // 注意:DerivedNoVirtual 的析构函数没有被调用!
    // data_ 指向的 1000 个 int 内存泄漏了
    // 而且这是未定义行为
}

// ============================
// 示例2:使用虚析构函数解决问题
// ============================

class BaseVirtual {
public:
    BaseVirtual() {
        std::cout << "BaseVirtual 构造" << std::endl;
    }
    // 虚析构函数
    virtual ~BaseVirtual() {
        std::cout << "BaseVirtual 析构" << std::endl;
    }
};

class DerivedVirtual : public BaseVirtual {
    int* data_;
public:
    DerivedVirtual() : data_(new int[1000]) {
        std::cout << "DerivedVirtual 构造(分配了内存)" << std::endl;
    }
    ~DerivedVirtual() override {
        delete[] data_;
        std::cout << "DerivedVirtual 析构(释放了内存)" << std::endl;
    }
};

void virtual_dtor_correct() {
    BaseVirtual* ptr = new DerivedVirtual();
    delete ptr;
    // 输出:
    //   BaseVirtual 构造
    //   DerivedVirtual 构造(分配了内存)
    //   DerivedVirtual 析构(释放了内存)
    //   BaseVirtual 析构
    // 正确:先调用派生类析构,再调用基类析构
}

// ============================
// 示例3:纯虚析构函数
// ============================

class AbstractBase {
public:
    // 纯虚析构函数:让类成为抽象类,但仍需提供定义
    virtual ~AbstractBase() = 0;
};

// 纯虚析构函数必须有定义(因为派生类析构时会调用基类析构)
AbstractBase::~AbstractBase() {
    std::cout << "AbstractBase 析构" << std::endl;
}

class Concrete : public AbstractBase {
public:
    ~Concrete() override {
        std::cout << "Concrete 析构" << std::endl;
    }
};

void pure_virtual_dtor_demo() {
    // AbstractBase obj;  // 编译错误:抽象类不能实例化
    AbstractBase* ptr = new Concrete();
    delete ptr;
    // 输出:
    //   Concrete 析构
    //   AbstractBase 析构
}

// ============================
// 示例4:什么时候不需要虚析构函数
// ============================

// 情况1:不会被继承的类(用 final 标记)
class Leaf final {
public:
    ~Leaf() {}  // 不需要虚析构
};

// 情况2:不通过基类指针删除
class Config {
public:
    ~Config() {}  // 如果不通过基类指针 delete,可以不虚
};

class AppConfig : public Config {
    // 只要不写 Config* p = new AppConfig(); delete p; 就没问题
};

// 情况3:受保护的非虚析构函数
class SafeBase {
protected:
    ~SafeBase() {}  // protected 防止通过基类指针 delete
public:
    virtual void doSomething() = 0;
};
// 外部无法写 delete safeBasePtr; 因为析构函数是 protected 的

// ============================
// 示例5:智能指针与虚析构函数
// ============================

void smart_pointer_demo() {
    // shared_ptr 有类型擦除,即使基类没有虚析构也能正确销毁
    // 但这不是好的实践,仍然推荐使用虚析构函数
    {
        std::shared_ptr<BaseNoVirtual> sp =
            std::make_shared<DerivedNoVirtual>();
        // shared_ptr 内部记住了 DerivedNoVirtual 的删除器
        // 销毁时会正确调用 DerivedNoVirtual 的析构函数
    }
    std::cout << "shared_ptr 正确销毁了对象" << std::endl;

    // unique_ptr 没有类型擦除,依赖虚析构函数
    {
        std::unique_ptr<BaseVirtual> up =
            std::make_unique<DerivedVirtual>();
        // 依赖虚析构函数正确销毁
    }

    // 注意:unique_ptr<BaseNoVirtual> 指向 DerivedNoVirtual
    // 仍然是未定义行为(和裸指针一样)
}

// ============================
// 示例6:虚析构函数的开销
// ============================

class Lightweight {
    int x;
public:
    ~Lightweight() {}  // 非虚:sizeof 可能是 4
};

class Polymorphic {
    int x;
public:
    virtual ~Polymorphic() {}  // 虚:sizeof 可能是 16(多了 vptr)
};

void overhead_demo() {
    std::cout << "sizeof(Lightweight) = " << sizeof(Lightweight) << std::endl;
    std::cout << "sizeof(Polymorphic) = " << sizeof(Polymorphic) << std::endl;
    // 虚析构函数引入 vptr,增加一个指针大小的开销
}

int main() {
    std::cout << "=== 没有虚析构的问题 ===" << std::endl;
    no_virtual_dtor_problem();

    std::cout << "\n=== 虚析构函数解决 ===" << std::endl;
    virtual_dtor_correct();

    std::cout << "\n=== 纯虚析构函数 ===" << std::endl;
    pure_virtual_dtor_demo();

    std::cout << "\n=== 智能指针 ===" << std::endl;
    smart_pointer_demo();

    std::cout << "\n=== 开销对比 ===" << std::endl;
    overhead_demo();

    return 0;
}

什么时候需要虚析构函数 ​

场景是否需要虚析构原因
类有虚函数(多态基类)需要会通过基类指针删除派生对象
纯接口类需要同上
不会被继承的类(final)不需要没有派生类
不通过基类指针删除不需要静态类型和动态类型一致
受保护析构的基类不需要外部无法通过基类指针 delete

常见问题 ​

为什么纯虚析构函数还需要定义?

因为派生类对象销毁时,析构函数的调用链是从派生类到基类。即使基类析构是纯虚的,派生类的析构仍然会调用它。所以纯虚析构函数必须有函数体(可以为空)。

shared_ptr 为什么能在没有虚析构函数的情况下正确销毁?

shared_ptr 使用了类型擦除技术。在 make_shared<Derived>() 时,它记住了 Derived 类型的删除器。销毁时直接调用 Derived 的析构函数,不需要通过虚函数机制。但这不是推荐做法,仍然应该给多态基类加虚析构。

Scott Meyers 的规则是什么?

如果一个类有任何虚函数,它就应该有虚析构函数。如果一个类不打算作为基类使用,就不应该有虚析构函数。

适用场景 ​

  • 所有用作多态基类的类
  • 抽象接口类
  • 需要通过基类指针管理对象生命周期的场景

注意事项 ​

  • 编译器警告 -Wnon-virtual-dtor 可以帮你检查
  • 派生类析构函数加 override 可以防止拼写错误
  • 虚析构函数引入 vptr 开销(一个指针大小)
  • 不要给不会被继承的类加虚析构(浪费空间)
  • C++11 的 final 关键字可以阻止类被继承

总结 ​

通过基类指针 delete 派生类对象时,基类必须有虚析构函数,否则是未定义行为。这是 C++ 面试中最基础也最重要的知识点之一。规则很简单:有虚函数就要有虚析构函数。纯虚析构函数可以让类成为抽象类,但必须提供定义。shared_ptr 通过类型擦除绕开了这个限制,但这不是推荐做法。