如何在C++11的领域上下文环境中追踪异常？

针对你提出的需求——在异常传播时添加领域上下文信息，同时能捕获最内层的实际错误，以下是几种可行的解决方案，按推荐程度排序：

方案1：自定义业务异常基类（推荐） #

这是最符合C++异常设计理念的方案，适合项目中统一异常体系的场景。通过自定义基类绑定上下文栈和错误信息，既支持按具体类型捕获异常，又能保留完整的上下文。

代码示例 #

#include <iostream>
#include <exception>
#include <vector>
#include <sstream>

class DomainException : public std::exception {
private:
    std::string root_msg;
    std::vector<std::string> context_stack;
    mutable std::string full_msg;

    void rebuild_full_msg() const {
        std::ostringstream oss;
        oss << root_msg;
        for (const auto& ctx : context_stack) {
            oss << "\n  上下文: " << ctx;
        }
        full_msg = oss.str();
    }

public:
    explicit DomainException(std::string msg) : root_msg(std::move(msg)) {}

    // 添加当前场景的上下文信息
    void add_context(std::string ctx) {
        context_stack.push_back(std::move(ctx));
        full_msg.clear(); // 标记需要重新构建完整错误信息
    }

    const char* what() const noexcept override {
        if (full_msg.empty()) {
            rebuild_full_msg();
        }
        return full_msg.c_str();
    }
};

// 具体业务异常示例
class ImageLoadError : public DomainException {
public:
    explicit ImageLoadError(const std::string& filename)
        : DomainException("加载图片失败: " + filename) {}
};

void process_image(const std::string& filename) {
    throw ImageLoadError(filename);
}

void run() {
    try {
        process_image("foo.png");
    } catch (DomainException& e) {
        e.add_context("run() 执行失败");
        throw; // 重新抛出带新增上下文的异常
    }
}

int main() {
    try {
        run();
    } catch (const ImageLoadError& e) {
        std::cerr << "捕获到图片加载错误:\n" << e.what() << std::endl;
    } catch (const DomainException& e) {
        std::cerr << "捕获到业务异常:\n" << e.what() << std::endl;
    }
}

优点 #

• 异常对象与上下文绑定，不会丢失信息
• 支持按具体异常类型捕获，同时获取完整上下文栈
• 类型安全，符合C++异常设计规范

缺点 #

• 无法处理非自定义异常（如内置类型、第三方库抛出的非std::exception子类），但实际项目中应避免抛出这类异常

方案2：异常包装类+std::exception_ptr #

适合需要处理任意类型异常（包括内置类型、第三方异常）的场景，通过包装类保存上下文和内层异常的指针，再用工具函数提取最内层错误。

代码示例 #

#include <iostream>
#include <exception>
#include <sstream>

class ContextualError : public std::exception {
private:
    std::string context;
    std::exception_ptr inner_err;
    mutable std::string full_msg;

    void rebuild_msg() const {
        std::ostringstream oss;
        oss << context;
        if (inner_err) {
            try {
                std::rethrow_exception(inner_err);
            } catch (const std::exception& e) {
                oss << ": " << e.what();
            } catch (const int& code) {
                oss << ": 错误码 " << code;
            } catch (...) {
                oss << ": 未知错误类型";
            }
        }
        full_msg = oss.str();
    }

public:
    ContextualError(std::string ctx, std::exception_ptr inner)
        : context(std::move(ctx)), inner_err(std::move(inner)) {}

    const char* what() const noexcept override {
        if (full_msg.empty()) {
            rebuild_msg();
        }
        return full_msg.c_str();
    }

    std::exception_ptr get_inner() const {
        return inner_err;
    }
};

// 递归提取最内层异常的工具函数
template <typename T>
bool extract_inner_exception(const std::exception_ptr& ep, T& out) {
    if (!ep) return false;
    try {
        std::rethrow_exception(ep);
    } catch (const ContextualError& ce) {
        return extract_inner_exception(ce.get_inner(), out);
    } catch (const T& e) {
        out = e;
        return true;
    } catch (...) {
        return false;
    }
}

// 打印完整上下文栈的工具函数
void print_error_stack(const std::exception_ptr& ep) {
    if (!ep) return;
    try {
        std::rethrow_exception(ep);
    } catch (const ContextualError& ce) {
        std::cerr << "上下文: " << ce.context << std::endl;
        print_error_stack(ce.get_inner());
    } catch (const std::exception& e) {
        std::cerr << "根错误: " << e.what() << std::endl;
    } catch (const int& code) {
        std::cerr << "根错误码: " << code << std::endl;
    } catch (...) {
        std::cerr << "根错误: 未知非异常类型" << std::endl;
    }
}

void run() {
    try {
        throw 1; // 示例内置类型异常
    } catch (...) {
        throw ContextualError("run() 执行失败", std::current_exception());
    }
}

int main() {
    try {
        run();
    } catch (...) {
        auto ep = std::current_exception();
        int error_code;
        if (extract_inner_exception(ep, error_code)) {
            std::cerr << "捕获到错误码: " << error_code << std::endl;
            std::cerr << "完整错误栈:\n";
            print_error_stack(ep);
        } else {
            try {
                std::rethrow_exception(ep);
            } catch (const std::exception& e) {
                std::cerr << "捕获到异常: " << e.what() << std::endl;
            }
        }
    }
}

优点 #

• 可以处理任意类型的异常，包括内置类型和第三方异常
• 上下文与异常绑定，不会丢失信息

缺点 #

• 无法直接按类型捕获最内层异常，需要通过工具函数提取
• 代码复杂度较高

方案3：线程局部存储(TLS)保存上下文栈 #

适合快速实现、不需要严格绑定异常和上下文的场景，通过线程局部变量存储上下文栈，异常传播时添加信息，最终捕获时读取。

代码示例 #

#include <iostream>
#include <exception>
#include <vector>
#include <string>

thread_local std::vector<std::string> g_error_context;

void run() {
    try {
        throw 1;
    } catch (...) {
        g_error_context.push_back("run() 执行失败");
        throw;
    }
}

int main() {
    try {
        run();
    } catch (const int& e) {
        std::cerr << "捕获到错误码: " << e << std::endl;
        std::cerr << "上下文栈:\n";
        for (const auto& ctx : g_error_context) {
            std::cerr << "  " << ctx << std::endl;
        }
        g_error_context.clear(); // 必须清理，避免影响后续代码
    }
}

优点 #

• 实现简单，不需要自定义异常类
• 可以直接按原始异常类型捕获

缺点 #

• 上下文与异常分离，异常跨线程传播会丢失上下文
• 需要手动清理上下文栈，容易遗漏导致残留

为什么不推荐std::throw_with_nested？ #

你遇到的问题正是std::throw_with_nested的设计局限：它将内层异常包裹在外层异常中，外层是新的异常类型，因此无法直接捕获内层异常类型。要访问内层异常，必须通过std::rethrow_if_nested递归遍历，不符合你希望直接捕获最内层实际错误的需求。

内容的提问来源于stack exchange，提问作者theChroma