错误处理策略选型：异常、std::expected 与错误码

异常：      错误对象沿调用栈「跳跃」传播，途经函数无需感知（除非声明 noexcept）
expected：  错误作为返回值的一部分「顺流而下」，每一层显式经手
错误码：    错误经由出参或返回 int 「顺流而下」，类型系统不强制检查

#include <fstream>
#include <stdexcept>
#include <string>

class ConfigError : public std::runtime_error {
public:
    enum class Kind { FileNotFound, InvalidSyntax, BadFieldType };
    explicit ConfigError(Kind k, const std::string& detail)
        : std::runtime_error(to_message(k, detail)), kind_(k) {}
    Kind kind() const noexcept { return kind_; }
private:
    static std::string to_message(Kind k, const std::string& d);
    Kind kind_;
};

Config load_config(const std::string& path) {
    std::ifstream file(path);                        // 失败时不抛，靠状态位
    if (!file.is_open()) {
        throw ConfigError(ConfigError::Kind::FileNotFound, path);
    }
    std::string text{std::istreambuf_iterator<char>(file), {}};
    try {
        return parse_json(text);                     // parse_json 内部也可能抛
    } catch (const ParseError& e) {
        throw ConfigError(ConfigError::Kind::InvalidSyntax, e.what());  // 翻译重抛
    }
}

Config c = load_config("app.json");   // 不写 try/catch，失败直接炸到 main
// 或者
try {
    Config c = load_config("app.json");
} catch (const ConfigError& e) {
    if (e.kind() == ConfigError::Kind::FileNotFound) use_default_config();
    else throw;                                        // 不认识的错误继续上抛
}

#include <expected>
#include <fstream>
#include <string>

enum class ConfigErr { FileNotFound, InvalidSyntax, BadFieldType };

std::expected<Config, ConfigErr> load_config(const std::string& path) {
    std::ifstream file(path);
    if (!file.is_open()) {
        return std::unexpected(ConfigErr::FileNotFound);
    }
    std::string text{std::istreambuf_iterator<char>(file), {}};
    if (!is_valid_json(text)) {
        return std::unexpected(ConfigErr::InvalidSyntax);
    }
    Config c = parse_json_lenient(text);
    if (!c.fields_all_valid()) {
        return std::unexpected(ConfigErr::BadFieldType);
    }
    return c;
}

// 姿势一：显式分支（底层代码、需要具体处理每种错误）
auto result = load_config("app.json");
if (result) {
    use(result.value());
} else {
    switch (result.error()) {
        case ConfigErr::FileNotFound:  use_default_config(); break;
        case ConfigErr::InvalidSyntax: report_and_exit();    break;
        case ConfigErr::BadFieldType:  repair_fields();      break;
    }
}

// 姿势二：monadic 链式（上层胶水代码，任何一步失败整体失败）
auto final_cfg = load_config(path)
    .or_else([](ConfigErr e) { log(e); return repair_config(path); })
    .and_then([](Config c) { return validate_remote_fields(c); });

#include <optional>
#include <string_view>

enum class ConfigErr : int { Ok = 0, FileNotFound = 1, InvalidSyntax = 2, BadFieldType = 3 };

// 风格一：出参错误码，返回 optional（POSIX/Windows API 常见变体）
std::optional<Config> load_config(const std::string& path, ConfigErr* err);

// 风格二：last_error 线程局部变量（C 运行库 errno 风格）
std::optional<Config> load_config(const std::string& path);
ConfigErr last_config_error();

ConfigErr err;
auto cfg = load_config("app.json", &err);
if (!cfg) {                       // 第 1 步：检查 optional
    switch (err) {                // 第 2 步：检查错误码——忘了就只知道「失败」不知道「为什么」
        case ConfigErr::FileNotFound: use_default_config(); break;
        default: report_and_exit(); break;
    }
}

// 异常版：重试逻辑要靠 catch 包循环
Config fetch_config_ex(const std::string& url) {
    for (int attempt = 0; ; ++attempt) {
        try {
            return http_get_json(url);
        } catch (const NetTimeout&) {
            if (attempt == 2) throw;               // 三次失败后放弃，继续上抛
        }
    }
}

// expected 版：重试是纯值变换，无控制流跳转
std::expected<Config, NetErr> fetch_config_ex(const std::string& url) {
    std::expected<Config, NetErr> r = std::unexpected(NetErr::NotAttempted);
    for (int attempt = 0; attempt < 3; ++attempt) {
        r = http_get_json_ex(url);
        if (r) return r;                            // 成功立即短路
        if (r.error() != NetErr::Timeout) break;     // 非超时错误不重试
    }
    return r;
}

class TcpConnection {
public:
    TcpConnection(const std::string& host, std::uint16_t port) {
        fd_ = ::socket(AF_INET, SOCK_STREAM, 0);
        if (fd_ < 0) {
            throw std::system_error(errno, std::system_category(), "socket");
        }
        if (::connect(fd_, addr(host, port)) < 0) {
            ::close(fd_);                          // 易错点：抛之前必须手动清理已获资源
            throw std::system_error(errno, std::system_category(), "connect");
        }
    }
    ~TcpConnection() { if (fd_ >= 0) ::close(fd_); }
private:
    int fd_ = -1;
};

static std::expected<TcpConnection, NetErr>
try_connect(const std::string& host, std::uint16_t port);   // 工厂函数绕开构造约束

// 异常通道：noexcept 是性能承诺 + 终止承诺
void hot_path() noexcept {
    // 内部所有可能抛的调用必须就地消化，或保证不会抛
    // 易错点：noexcept 函数里调用非 noexcept 函数 = 埋雷
}

// expected 通道：天然友好——失败走返回值，函数可以大胆标 noexcept
std::expected<Config, ConfigErr> load() noexcept {
    // 所有失败都变成值返回，没有异常逃逸风险
}

// 移动构造为什么常标 noexcept：vector 扩容时只有 noexcept 移动构造
// 才敢用移动；否则退回拷贝保证强异常安全（详见 190 篇附录 C）

这个失败是程序不变量被破坏吗（继续跑没意义）？
  是 --> 异常（或直接 terminate / assert）
  否 -->
    是构造函数 / 移动 / swap / 析构（无法用返回值的场合）？
      是 --> 异常（析构内严格禁止抛）
      否 -->
        会穿越 C ABI / extern "C" / 无异常编译（-fno-exceptions）？
          是 --> 错误码
          否 -->
            调用方大概率要区分多种错误并分别处理（重试/降级/提示用户）？
              是 --> std::expected
              否 --> 异常（让正常路径保持干净）