C++ 中 rethrow_exception：安全重抛异常的完整指南

在现代 C++ 异常处理机制中，std::rethrow_exception 是一个关键但常被误解的工具。它并非简单地“再次抛出当前异常”，而是用于在捕获异常后，将异常对象以 std::exception_ptr 的形式保存，并在完全不同的上下文（如另一线程、延迟执行函数或异常安全封装层）中重新激活并抛出该异常。正确理解其语义、生命周期约束与使用边界，是编写健壮、跨线程异常传播逻辑的基础。

为什么需要 rethrow_exception？

C++ 标准规定：catch 块内直接使用 throw;（无操作数）可重抛当前正在处理的异常；但该语法仅限于当前 catch 块内部，且要求异常对象仍处于活跃状态。一旦 catch 块退出，原始异常即被销毁，此时再调用 throw; 将导致未定义行为（通常为程序终止）。而实际开发中，我们常需：

• 在工作线程中捕获异常，传递给主线程统一处理；
• 构建异步任务框架，允许任务回调中报告上游错误；
• 实现异常中立的资源管理器（如 std::future 内部机制）；

这些场景均依赖 std::current_exception() 获取异常快照，并通过 std::rethrow_exception() 在目标上下文中恢复异常状态。

核心机制：exception_ptr 是异常的“只读快照”

std::exception_ptr 并非原始异常的引用或指针，而是一个不透明的、线程安全的共享句柄。它通过引用计数管理底层异常对象的生命周期，确保只要存在至少一个 exception_ptr 指向它，异常数据就不会被析构。

#include <exception>
#include <iostream>
#include <thread>
#include <vector>

void worker_thread(std::exception_ptr& err_out) {
    try {
        // 模拟可能抛出异常的操作
        throw std::runtime_error("Worker failed: invalid input");
    } catch (...) {
        // 捕获任意异常，并保存其快照
        err_out = std::current_exception();
    }
}

int main() {
    std::exception_ptr worker_err;

    std::thread t(worker_thread, std::ref(worker_err));
    t.join();

    // 主线程中检查并重抛
    if (worker_err) {
        try {
            std::rethrow_exception(worker_err);  // 此处真正抛出原始异常
        } catch (const std::exception& e) {
            std::cout << "Caught in main: " << e.what() << '\n';
        }
    }
}

注意：std::rethrow_exception 接收 exception_ptr，不接收 const exception_ptr& 或 exception_ptr&& —— 它接受的是 exception_ptr 值（标准要求其为可复制类型），内部会增加引用计数。

关键限制与陷阱

1. 空 exception_ptr 不可重抛

若传入空指针（如默认构造的 exception_ptr），std::rethrow_exception 将调用 std::terminate()。务必先判空：

if (eptr) {
    std::rethrow_exception(eptr);
} else {
    // 处理无异常情况，例如返回默认值或记录日志
}

2. 异常对象不可变性

exception_ptr 所指向的异常对象是只读的。无法通过它修改 what() 返回内容，也无法向下转型（除非原异常类型已知且支持 dynamic_cast）。

3. 跨线程传播需保证异常类型可访问

若异常类型在目标线程不可见（如仅在源编译单元定义的私有类），rethrow_exception 仍能抛出，但 catch 块可能无法匹配。推荐使用标准异常或显式导出的异常基类。

实用模式：异常安全的异步结果封装

以下示例展示如何封装一个支持异常传播的简易 Result<T> 类型：

#include <exception>
#include <optional>
#include <utility>

template<typename T>
class Result {
    std::optional<T> value_;
    std::exception_ptr error_;

public:
    explicit Result(T v) : value_(std::move(v)) {}
    explicit Result(std::exception_ptr e) : error_(std::move(e)) {}

    bool has_value() const noexcept { return value_.has_value(); }
    bool has_error() const noexcept { return static_cast<bool>(error_); }

    const T& value() const& {
        if (!value_) std::rethrow_exception(error_);
        return *value_;
    }

    void rethrow_if_error() const {
        if (error_) std::rethrow_exception(error_);
    }
};

// 使用示例
Result<int> compute_safely(bool should_fail) {
    try {
        if (should_fail) throw std::logic_error("Computation aborted");
        return Result<int>(42);
    } catch (...) {
        return Result<int>(std::current_exception());
    }
}

此设计使调用方能明确区分成功路径与错误路径，同时保留完整的异常上下文，避免错误被静默吞没。

结语：合理使用，强化异常韧性

std::rethrow_exception 不是替代 throw; 的快捷方式，而是构建复杂异常传播拓扑的基础设施。它赋予开发者跨越作用域、线程甚至模块边界传递错误语义的能力。掌握其与 std::current_exception() 的配对使用、严格校验空指针、理解 exception_ptr 的生命周期语义，是编写高可靠性 C++ 系统的关键一环。在异步编程、协程错误处理及泛型库设计中，这一机制将持续发挥不可替代的作用。