C++ 中 current_exception：捕获与传递异常对象的智能指针机制

在现代 C++ 异常处理体系中，std::current_exception() 是一个被低估却极为关键的工具。它允许程序在异常被抛出但尚未被捕获的“悬空”时刻，安全地获取一个指向异常对象的智能句柄——std::exception_ptr。这一机制突破了传统 try-catch 的作用域限制，使异常可以在不同线程、不同函数甚至不同调用栈之间被传递、延迟处理或统一日志化。本文将系统解析 current_exception 的语义、使用场景、生命周期管理及常见陷阱，帮助开发者构建更健壮、可调试的异常处理逻辑。

什么是 std::exception_ptr 与 current_exception()

std::exception_ptr 是一个不透明的、可拷贝的、空安全的智能指针类型，用于间接持有当前正在传播（或刚被抛出）的异常对象。它本身不拥有异常类型信息，也不提供直接访问接口；其价值在于延迟捕获与跨上下文传递。而 std::current_exception() 是唯一能生成该指针的函数，仅在异常处理过程中（即 catch 块内，或 noexcept 函数中异常被终止前）调用才返回有效值；其他时刻返回空指针（nullptr 语义）。

值得注意的是：current_exception() 不会重新抛出异常，也不会改变异常传播状态——它只是对当前异常对象的一次“快照式引用”。

#include <exception>
#include <iostream>
#include <stdexcept>

void demonstrate_current_exception() {
    try {
        throw std::runtime_error("Operation failed unexpectedly");
    } catch (...) {
        // 在 catch(...) 中调用，安全获取异常句柄
        std::exception_ptr eptr = std::current_exception();
        if (eptr) {
            std::cout << "Valid exception_ptr acquired.\n";
        } else {
            std::cout << "No active exception.\n";
        }
    }
}

跨作用域传递异常：典型应用场景

最实用的模式是将异常从子任务中“提升”至主流程统一处理。例如，在异步任务或线程池中，子线程无法直接向主线程抛出异常。此时可借助 exception_ptr 封装异常，并通过共享状态传递：

#include <thread>
#include <vector>
#include <memory>

std::exception_ptr g_eptr;

void worker_task() {
    try {
        // 模拟可能失败的操作
        if (true) {
            throw std::logic_error("Worker logic error");
        }
    } catch (...) {
        // 捕获并保存异常句柄，供主线程检查
        g_eptr = std::current_exception();
    }
}

void main_flow() {
    std::thread t(worker_task);
    t.join();

    // 主线程检查是否有异常发生
    if (g_eptr) {
        try {
            std::rethrow_exception(g_eptr); // 重新抛出，进入标准异常处理链
        } catch (const std::exception& e) {
            std::cerr << "Caught in main: " << e.what() << "\n";
        }
    }
}

该模式避免了全局错误码或自定义错误结构体的繁琐封装，保持了异常语义的完整性。

生命周期与资源安全：何时会失效？

std::exception_ptr 的底层实现依赖于异常对象的存储管理。C++ 标准规定：只要至少有一个 exception_ptr 指向某异常对象，该对象的存储就不会被释放。换言之，exception_ptr 是引用计数式管理的。当最后一个 exception_ptr 被销毁，且无活跃 catch 块持有该异常时，异常对象内存才被回收。

因此，以下写法是安全的：

std::exception_ptr safe_capture() {
    try {
        throw std::domain_error("Transient error");
    } catch (...) {
        return std::current_exception(); // 返回后，异常对象仍存活
    }
}

// 调用方可长期持有该 ptr
auto ptr = safe_capture();
// ... 后续任意时刻 rethrow_exception(ptr) 都有效

但需警惕：若在 catch 块外调用 current_exception()，结果为 null；若在 catch 中未用 ... 或具体类型捕获，而异常类型不匹配，则 current_exception() 不可用。

与 std::rethrow_exception 协同工作

std::rethrow_exception(exception_ptr) 是 current_exception() 的天然搭档。它将 exception_ptr 所指异常重新注入当前上下文，触发标准异常查找机制。注意：它不是“复制异常”，而是恢复原始异常的传播路径，包括完整的类型信息与 what() 内容。

#include <string>

void log_and_rethrow(std::exception_ptr eptr) {
    if (!eptr) return;

    try {
        std::rethrow_exception(eptr);
    } catch (const std::runtime_error& e) {
        std::cerr << "[RUNTIME] " << e.what() << "\n";
        throw; // 继续传播
    } catch (const std::exception& e) {
        std::cerr << "[GENERIC] " << e.what() << "\n";
        throw;
    } catch (...) {
        std::cerr << "[UNKNOWN] Unhandled exception type\n";
        throw;
    }
}

此函数实现了类型感知的日志记录，同时保持异常链不中断。

总结：让异常真正“可编程”

std::current_exception() 并非语法糖，而是将异常从控制流机制升华为一等数据对象的关键桥梁。它使异常具备了可存储、可传递、可延迟决策的能力，契合现代 C++ 对资源安全与抽象能力的双重追求。掌握其行为边界（如仅限 catch 内调用）、理解其引用计数本质、善用 rethrow_exception 进行类型分发，是编写高可靠性系统代码的必备素养。在调试复杂错误链、构建统一错误中心、实现协程异常转发等进阶场景中，这一机制将持续展现不可替代的价值。