一、虚函数与异常：一个容易被忽视的角落

说实话，虚函数和异常安全这个话题，我在刚入行那几年几乎没怎么认真想过。那时候觉得，异常嘛，try-catch 就完了；虚函数嘛，多态调用就完了。直到有一次，我在一个金融交易系统里遇到了一个诡异的崩溃——析构函数里抛了个异常，整个进程直接 abort 了。嗯，从那以后，我再也不敢小看这个组合了。

今天咱们就来聊聊，虚函数和异常安全之间那些「剪不断理还乱」的关系。说白了，就是搞清楚：当多态遇上异常，到底该怎么写代码才不翻车？

二、虚函数中的异常处理：谁该负责捕获？

2.1 基类虚函数抛异常，派生类怎么办？

先看一个最简单的场景。基类有个虚函数，它可能会抛异常。派生类重写这个函数时，能不能抛不同的异常？

class Base {
public:
    virtual void process() {
        // 可能抛出 std::runtime_error
        throw std::runtime_error("Base error");
    }
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void process() override {
        // 可以抛不同的异常吗？
        throw std::logic_error("Derived error");
    }
};

答案是：可以，但有条件。C++ 标准规定，派生类虚函数抛出的异常类型，必须是基类虚函数异常类型的子集。如果基类虚函数没有异常规格说明（也就是没写 throw() 或 noexcept），那派生类可以抛任何异常。

核心原则：派生类虚函数抛出的异常，不能比基类虚函数抛出的异常「更宽泛」。说白了，就是子类不能比父类更「任性」。

2.2 异常规格说明的变迁

我记得早期 C++ 有个东西叫「异常规格说明」，就是函数后面写 throw(type1, type2)。比如：

// 老式写法（C++98/03）
virtual void oldWay() throw(std::runtime_error, std::logic_error);

但这个东西后来被废弃了。为什么？因为它在运行时检查，性能开销大，而且容易写出 bug。C++11 之后，我们有了 noexcept，简单明了：

class Base {
public:
    // 承诺不抛异常
    virtual void safeProcess() noexcept;
    // 可能抛异常
    virtual void riskyProcess();
};

我的建议：虚函数能用 noexcept 就用 noexcept。这不仅是文档，更是给编译器优化的机会。我在项目中见过太多「理论上不抛异常，实际上抛了」的坑，noexcept 至少能让程序在崩溃前给你一个明确的信号。

三、析构函数中的异常：绝对不能做的事

这个话题，我每次讲课时都会多说两句。因为 析构函数里抛异常，是 C++ 中最危险的操作之一。

3.1 为什么析构函数不能抛异常？

想象一下这个场景：一个对象在析构过程中，已经释放了一半的资源，突然抛了个异常。那另一半资源怎么办？更糟的是，如果析构函数是在栈展开（stack unwinding）过程中被调用的，那就会触发 std::terminate()，程序直接挂掉。

class ResourceManager {
public:
    ~ResourceManager() {
        // 危险！如果这里抛异常...
        cleanup();  // 可能抛出异常
    }
    
private:
    void cleanup() {
        // 假设这里会抛异常
        throw std::runtime_error("cleanup failed");
    }
};

void someFunction() {
    ResourceManager rm;
    // 如果这里抛异常，rm 的析构函数会被调用
    // 如果析构函数又抛异常... 程序就完了
    throw std::logic_error("some error");
}

铁律：析构函数永远不要抛出异常。如果析构函数调用的函数可能抛异常，一定要在析构函数内部捕获并处理掉。我曾经在一个网络库中看到析构函数抛异常导致整个服务器崩溃的案例，那真是血泪教训。

3.2 虚析构函数与异常安全

当基类有虚析构函数时，情况更微妙。因为派生类的析构函数会覆盖基类的析构函数，如果基类析构函数是 noexcept，派生类析构函数也必须是 noexcept（默认就是）。

class Base {
public:
    virtual ~Base() = default;  // 隐式 noexcept
};

class Derived : public Base {
public:
    ~Derived() {
        // 这里如果抛异常，会直接 terminate
        // 因为基类析构函数是 noexcept
    }
};

所以，虚析构函数最好都标记为 noexcept。这能强制所有派生类析构函数也不抛异常，从根源上杜绝问题。

四、RAII 与多态：异常安全的黄金搭档

4.1 RAII 的基本思想

RAII（Resource Acquisition Is Initialization）说白了就是：资源在构造函数中获取，在析构函数中释放。这样，无论函数正常返回还是异常退出，析构函数都会被调用，资源总能被正确释放。

class FileHandler {
public:
    FileHandler(const char* filename) 
        : file_(fopen(filename, "r")) {
        if (!file_) {
            throw std::runtime_error("Cannot open file");
        }
    }
    
    ~FileHandler() {
        if (file_) {
            fclose(file_);  // 不会抛异常
        }
    }
    
    // 禁止拷贝，允许移动
    FileHandler(const FileHandler&) = delete;
    FileHandler& operator=(const FileHandler&) = delete;
    
private:
    FILE* file_;
};

4.2 RAII 与多态的结合

当 RAII 遇上多态，我们需要用智能指针来管理动态分配的对象。这样，即使发生异常，对象也能被正确析构。

class Base {
public:
    virtual void doWork() = 0;
    virtual ~Base() = default;
};

class DerivedA : public Base {
public:
    void doWork() override { /* ... */ }
};

class DerivedB : public Base {
public:
    void doWork() override { /* ... */ }
};

// 异常安全的工厂函数
std::unique_ptr<Base> createObject(int type) {
    if (type == 1) {
        return std::make_unique<DerivedA>();
    } else if (type == 2) {
        return std::make_unique<DerivedB>();
    }
    throw std::invalid_argument("Unknown type");
}

void process() {
    auto obj = createObject(1);  // 即使这里抛异常，也没内存泄漏
    obj->doWork();
    // unique_ptr 析构时自动 delete 对象
}

关键点：用 std::unique_ptr 或 std::shared_ptr 管理多态对象，是 C++ 中实现异常安全的标准做法。我个人的习惯是：只要涉及动态分配的多态对象，一律用智能指针，绝不裸 new。

五、知识体系总览

下面这张图，把本章的核心知识点串了起来。你可以看到，虚函数与异常安全涉及三个层面：异常规格、析构函数行为、RAII 实践。

虚函数与异常安全知识体系 虚函数 + 异常安全 异常规格说明 析构函数中的异常 RAII 与多态 派生类异常必须是基类的子集 noexcept 替代 throw() 规格 析构函数绝不抛异常 虚析构函数默认 noexcept 智能指针管理多态对象 资源获取即初始化 核心目标：异常发生时，资源不泄漏，程序不崩溃

六、实战中的避坑指南

最后，分享几个我踩过的坑，希望能帮你少走弯路：

  • 不要在虚函数中直接抛异常，除非你明确知道调用方会捕获。更好的做法是返回错误码或使用 std::optional。
  • 虚析构函数一定要是 noexcept。C++11 之后默认就是，但如果你手动写了析构函数，记得加上 noexcept。
  • RAII 对象不要用裸指针管理。用 std::unique_ptr 或 std::shared_ptr，它们天生就是异常安全的。
  • 如果必须在析构函数中调用可能抛异常的函数，用 try-catch 吞掉异常，或者记录日志后继续。总之，别让异常逃出析构函数。

一个小技巧：我习惯在基类虚析构函数上显式写 noexcept，这样派生类如果试图在析构函数中抛异常，编译器会给出警告。这比运行时崩溃要好得多。

好了，关于虚函数与异常安全，今天就聊到这里。记住一句话：异常安全不是锦上添花，而是底线。写多态代码时，多想想「如果这里抛异常了，资源能正确释放吗？」——养成这个习惯，能帮你省下无数调试时间。

← 上一章 📖 返回目录 下一章 →