虚析构函数的必要性
面试考点
虚析构函数是 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 通过类型擦除绕开了这个限制,但这不是推荐做法。