这问题戳中了标准异常的痛点——它们太通用了，没法携带上下文信息（比如哪个文件、哪个字段出的问题），导致顶层捕获时只能拿到模糊的错误描述。要实现友好的错误报告，核心思路是用自定义异常存储结构化错误信息，并在各个层级把底层通用异常包装成带上下文的自定义异常再抛出。下面一步步给你实现方案：

第一步：定义带结构化信息的自定义异常 #

标准异常（std::invalid_argument、std::bad_alloc）没有存储文件名、字段位置这些关键信息，我们需要自己定义异常类，把这些结构化数据存进去，方便后续生成友好提示，还能轻松支持多语言（因为错误类型是枚举，不是硬编码字符串）。

#include <stdexcept>
#include <string>
#include <optional>
#include <string_view>

// 枚举所有可能的配置加载错误类型，方便后续多语言适配
enum class ConfigErrorType {
    FileNotFoundOrInvalid,   // 文件不存在或JSON格式非法
    RootNotAnArray,          // 配置文件根节点不是数组
    MissingRequiredField,    // 字段缺失（比如name/value）
    InvalidFieldType,        // 字段类型错误（比如value不是数字）
    OutOfMemory              // 内存不足（不可恢复）
};

class ConfigLoadingError : public std::exception {
public:
    ConfigLoadingError(ConfigErrorType errType, std::string fileName, 
                       std::optional<std::string> fieldContext = std::nullopt)
        : errType_(errType), fileName_(std::move(fileName)), fieldCtx_(std::move(fieldContext)) {}

    // 获取结构化错误信息的接口
    ConfigErrorType errorType() const noexcept { return errType_; }
    const std::string& fileName() const noexcept { return fileName_; }
    const std::optional<std::string>& fieldContext() const noexcept { return fieldCtx_; }

    // 可选：实现what()，但我们主要用结构化信息生成提示
    const char* what() const noexcept override {
        static const std::string_view messages[] = {
            "File not found or invalid JSON",
            "Root element is not an array",
            "Missing required field",
            "Invalid field type",
            "Out of memory"
        };
        return messages[static_cast<size_t>(errType_)].data();
    }

private:
    ConfigErrorType errType_;
    std::string fileName_;          // 出错的配置文件名
    std::optional<std::string> fieldCtx_; // 出错的字段上下文（比如"第2个字段"）
};

第二步：在各层级包装异常，添加上下文 #

现在要在每个可能抛通用异常的地方，捕获它们并包装成ConfigLoadingError，同时添加上下文（比如文件名、字段索引）：

优化parseConfField：精准捕获字段级错误 #

把每个可能出错的操作拆分到单独的try块，避免依赖what()的模糊判断：

void parseConfField(RelevantInfo& info, JsonObject field) {
    // 单独处理name字段的获取
    std::string fieldName;
    try {
        auto nameObj = field.at("name");
        fieldName = nameObj.as_string();
    } catch (const std::invalid_argument&) {
        // 抛一个带具体信息的异常，让上层包装
        throw std::runtime_error("Missing 'name' field");
    }

    // 单独处理value字段的获取
    double fieldValue;
    try {
        auto valueObj = field.at("value");
        fieldValue = valueObj.as_double();
    } catch (const std::invalid_argument& e) {
        if (std::string(e.what()).find("No entry named") != std::string::npos) {
            throw std::runtime_error("Missing 'value' field");
        } else {
            throw std::runtime_error("'value' is not a valid double");
        }
    }

    // 处理内存不足的情况（直接向上抛，不包装）
    try {
        info[fieldName] = fieldValue;
    } catch (const std::bad_alloc&) {
        throw;
    }
}

优化parseConfFile：添加上下文并包装异常 #

这里要把文件名、当前处理的字段索引添加上，再包装成自定义异常抛出：

void parseConfFile(RelevantInfo& info, char const* fileName) {
    try {
        // 捕获文件打开/解析错误
        auto const loadedConf = somelibrary::open(fileName);
        try {
            // 捕获根节点不是数组的错误
            auto const& confArray = loadedConf.as_array();
            size_t fieldIndex = 0;
            for (auto const& confField : confArray) {
                try {
                    parseConfField(info, confField);
                } catch (const std::runtime_error& e) {
                    // 添加上下文：文件名+字段位置，再包装成自定义异常
                    auto errType = (e.what() == std::string("Missing 'name' field") || e.what() == std::string("Missing 'value' field"))
                                   ? ConfigErrorType::MissingRequiredField
                                   : ConfigErrorType::InvalidFieldType;
                    throw ConfigLoadingError(
                        errType,
                        fileName,
                        std::string("Field #") + std::to_string(fieldIndex + 1) + ": " + e.what()
                    );
                }
                ++fieldIndex;
            }
        } catch (const std::invalid_argument&) {
            throw ConfigLoadingError(ConfigErrorType::RootNotAnArray, fileName);
        }
    } catch (const std::invalid_argument&) {
        throw ConfigLoadingError(ConfigErrorType::FileNotFoundOrInvalid, fileName);
    }
}

第三步：顶层实现可重试的友好错误处理 #

在parseAllConf里捕获自定义异常，根据结构化信息生成友好提示，支持用户修复后重试：

#include <iostream>
#include <string>
#include <cstdlib>

void parseAllConf() {
    RelevantInfo info;
    bool loadSuccess = false;

    while (!loadSuccess) {
        try {
            info.clear();
            parseConfFile(info, "a.json");
            parseConfFile(info, "b.json");
            parseConfFile(info, "c.json");
            loadSuccess = true;
            std::cout << "✅ All configuration files loaded successfully!" << std::endl;
        } catch (const ConfigLoadingError& err) {
            // 根据自定义异常的结构化信息生成友好提示
            std::string errorMsg;
            switch (err.errorType()) {
                case ConfigErrorType::FileNotFoundOrInvalid:
                    errorMsg = "❌ Error loading '" + err.fileName() + "': File does not exist or has invalid JSON syntax.";
                    break;
                case ConfigErrorType::RootNotAnArray:
                    errorMsg = "❌ Error loading '" + err.fileName() + "': Root element must be an array of config entries.";
                    break;
                case ConfigErrorType::MissingRequiredField:
                case ConfigErrorType::InvalidFieldType:
                    errorMsg = "❌ Error in '" + err.fileName() + "': " + err.fieldContext().value_or("Unknown issue");
                    break;
                case ConfigErrorType::OutOfMemory:
                    errorMsg = "❌ Fatal error: Out of memory while loading '" + err.fileName() + "'.";
                    std::cerr << errorMsg << std::endl;
                    std::exit(EXIT_FAILURE);
            }

            std::cerr << errorMsg << std::endl;
            std::cout << "Please fix the issue and press Enter to retry, or type 'quit' to exit: ";
            std::string userInput;
            std::getline(std::cin, userInput);
            if (userInput == "quit") {
                std::exit(EXIT_SUCCESS);
            }
        } catch (const std::bad_alloc&) {
            std::cerr << "❌ Fatal error: Out of memory. Exiting." << std::endl;
            std::exit(EXIT_FAILURE);
        } catch (const std::exception& unexpectedErr) {
            std::cerr << "❌ Unexpected error: " << unexpectedErr.what() << ". Exiting." << std::endl;
            std::exit(EXIT_FAILURE);
        }
    }
}

关键思路总结 #

1. 结构化错误信息是核心：自定义异常存储了文件名、错误类型、字段位置等信息，完全不依赖底层异常的what()字符串（避免因库版本变化导致判断失效），还能轻松做多语言适配（比如用ConfigErrorType枚举值查翻译字典）。
2. 异常包装传递上下文：每个层级捕获底层通用异常后，添加上当前层级的上下文（比如文件名、字段索引），再包装成自定义异常抛出，顶层就能拿到完整的错误链路信息。
3. 区分可恢复与不可恢复错误：配置文件错误是可恢复的（用户修复后可重试），而内存不足是不可恢复的，直接提示后退出。
4. 精准捕获拆分try块：把每个可能出错的操作拆分到单独的try块，能更准确地判断错误类型，避免在一个try块里捕获所有异常导致的模糊判断。

内容来源于stack exchange