std::expected 错误处理模式 ​

面试考点 ​

C++23 引入的 std::expected<T, E> 是现代 C++ 错误处理的核心工具。面试官通过这道题考察你是否理解 expected 的语义(成功值或错误值)、与异常和 optional 的区别、以及 C++23 提供的单子操作(and_then、transform、or_else)如何实现链式错误处理。

核心概念 ​

std::expected<T, E> 表示一个操作的结果:要么包含成功值 T,要么包含错误值 E。它是值语义的,不做堆分配,不依赖异常机制。C++23 增加了单子操作,允许把多个可能失败的操作链接成管道,错误自动传播,不需要手动检查每一步。

基本示例 ​

cpp
#include <iostream>
#include <expected>
#include <string>
#include <vector>
#include <fstream>
#include <charconv>
#include <cmath>

// ============================
// 示例1:基本用法
// ============================

enum class ParseError {
    EmptyInput,
    InvalidFormat,
    OutOfRange
};

// 返回 expected:成功时是 int,失败时是 ParseError
std::expected<int, ParseError> parse_int(const std::string& s) {
    if (s.empty()) {
        return std::unexpected(ParseError::EmptyInput);
    }

    int result = 0;
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), result);

    if (ec == std::errc::invalid_argument) {
        return std::unexpected(ParseError::InvalidFormat);
    }
    if (ec == std::errc::result_out_of_range) {
        return std::unexpected(ParseError::OutOfRange);
    }
    if (ptr != s.data() + s.size()) {
        return std::unexpected(ParseError::InvalidFormat);
    }

    return result;  // 隐式转换为 expected<int, ParseError>
}

void basic_demo() {
    auto r1 = parse_int("42");
    if (r1.has_value()) {
        std::cout << "成功: " << r1.value() << std::endl;
    }

    auto r2 = parse_int("abc");
    if (!r2) {  // operator bool
        std::cout << "失败: ";
        switch (r2.error()) {
            case ParseError::EmptyInput: std::cout << "空输入"; break;
            case ParseError::InvalidFormat: std::cout << "格式错误"; break;
            case ParseError::OutOfRange: std::cout << "超出范围"; break;
        }
        std::cout << std::endl;
    }

    // value_or:失败时用默认值
    int val = parse_int("xyz").value_or(-1);
    std::cout << "value_or: " << val << std::endl;
}

// ============================
// 示例2:expected<void, E> 表示无返回值的操作
// ============================

enum class FileError { NotFound, PermissionDenied, WriteError };

std::expected<void, FileError> write_file(const std::string& path,
                                           const std::string& content) {
    std::ofstream file(path);
    if (!file.is_open()) {
        return std::unexpected(FileError::NotFound);
    }
    file << content;
    if (file.fail()) {
        return std::unexpected(FileError::WriteError);
    }
    return {};  // 成功,void 类型
}

void void_demo() {
    auto result = write_file("test_output.txt", "hello");
    if (result) {
        std::cout << "写入成功" << std::endl;
    } else {
        std::cout << "写入失败" << std::endl;
    }
}

// ============================
// 示例3:C++23 单子操作——链式处理
// ============================

// 验证:值必须为正数
std::expected<int, std::string> validate_positive(int n) {
    if (n <= 0) return std::unexpected("值必须为正数");
    return n;
}

// 计算:开方
std::expected<double, std::string> safe_sqrt(int n) {
    if (n < 0) return std::unexpected("不能对负数开方");
    return std::sqrt(static_cast<double>(n));
}

// 格式化:转为字符串(不可能失败)
std::string format_result(double val) {
    return "结果 = " + std::to_string(val);
}

void monadic_demo() {
    // 传统写法:每一步都要检查
    auto r1 = parse_int("16");
    if (!r1) { std::cout << "解析失败" << std::endl; return; }

    auto r2 = validate_positive(*r1);
    if (!r2) { std::cout << r2.error() << std::endl; return; }

    auto r3 = safe_sqrt(*r2);
    if (!r3) { std::cout << r3.error() << std::endl; return; }

    std::cout << format_result(*r3) << std::endl;

    // C++23 单子写法:链式管道,错误自动传播
    // 注意:需要统一错误类型
    /*
    auto result = parse_int_str("16")   // expected<int, string>
        .and_then(validate_positive)     // 可能失败,返回 expected
        .and_then(safe_sqrt)             // 可能失败,返回 expected
        .transform(format_result);       // 不会失败,返回转换后的值

    if (result) {
        std::cout << *result << std::endl;
    } else {
        std::cout << "错误: " << result.error() << std::endl;
    }
    */
}

// ============================
// 示例4:单子操作详解
// ============================

/*
四个单子操作:

and_then(f):
  - 有值时调用 f(value),f 返回 expected
  - 无值时直接传播错误
  - 用途:链接可能失败的操作

transform(f):
  - 有值时调用 f(value),f 返回普通值,自动包装为 expected
  - 无值时直接传播错误
  - 用途:链接不会失败的转换操作

or_else(f):
  - 有值时直接传播值
  - 无值时调用 f(error),f 返回 expected
  - 用途:错误恢复或错误转换

transform_error(f):
  - 有值时直接传播值
  - 无值时调用 f(error),f 返回新的错误类型
  - 用途:转换错误类型

选择指南:
  操作成功值且可能失败 → and_then
  操作成功值且不会失败 → transform
  操作错误值且可能恢复 → or_else
  操作错误值且只是转换 → transform_error
*/

// ============================
// 示例5:与异常和 optional 的对比
// ============================

// 异常方式
int divide_exception(int a, int b) {
    if (b == 0) throw std::runtime_error("除以零");
    return a / b;
}

// optional 方式:只知道失败,不知道原因
std::optional<int> divide_optional(int a, int b) {
    if (b == 0) return std::nullopt;
    return a / b;
}

// expected 方式:既知道失败,又知道原因
enum class MathError { DivideByZero, Overflow };

std::expected<int, MathError> divide_expected(int a, int b) {
    if (b == 0) return std::unexpected(MathError::DivideByZero);
    return a / b;
}

void comparison_demo() {
    // 异常:隐式控制流,可能被遗忘捕获
    try {
        auto r = divide_exception(10, 0);
    } catch (const std::exception& e) {
        std::cout << "异常: " << e.what() << std::endl;
    }

    // optional:调用者知道可能失败,但不知道原因
    auto r2 = divide_optional(10, 0);
    if (!r2) std::cout << "optional: 失败(原因未知)" << std::endl;

    // expected:调用者知道可能失败,也知道原因
    auto r3 = divide_expected(10, 0);
    if (!r3) {
        if (r3.error() == MathError::DivideByZero) {
            std::cout << "expected: 除以零" << std::endl;
        }
    }
}

// ============================
// 示例6:实际应用——配置解析
// ============================

struct Config {
    std::string host;
    int port;
    int max_connections;
};

enum class ConfigError {
    MissingField,
    InvalidPort,
    InvalidConnections
};

std::expected<int, ConfigError> parse_port(const std::string& s) {
    auto result = parse_int(s);
    if (!result) return std::unexpected(ConfigError::InvalidPort);
    if (*result < 1 || *result > 65535) {
        return std::unexpected(ConfigError::InvalidPort);
    }
    return *result;
}

std::expected<Config, ConfigError> load_config() {
    // 模拟从文件读取配置
    std::string host = "localhost";
    std::string port_str = "8080";
    std::string conn_str = "100";

    auto port = parse_port(port_str);
    if (!port) return std::unexpected(port.error());

    auto conn = parse_int(conn_str);
    if (!conn) return std::unexpected(ConfigError::InvalidConnections);
    if (*conn < 1) return std::unexpected(ConfigError::InvalidConnections);

    return Config{host, *port, *conn};
}

void config_demo() {
    auto config = load_config();
    if (config) {
        std::cout << "配置加载成功: " << config->host
                  << ":" << config->port
                  << " (max=" << config->max_connections << ")"
                  << std::endl;
    } else {
        std::cout << "配置加载失败" << std::endl;
    }
}

int main() {
    std::cout << "=== 基本用法 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== void 类型 ===" << std::endl;
    void_demo();

    std::cout << "\n=== 链式处理 ===" << std::endl;
    monadic_demo();

    std::cout << "\n=== 对比 ===" << std::endl;
    comparison_demo();

    std::cout << "\n=== 配置解析 ===" << std::endl;
    config_demo();

    return 0;
}

错误处理方式对比 ​

方式错误类型控制流性能调用者感知
返回错误码int显式最快容易忽略
异常任意隐式(栈展开)有开销可能遗忘 catch
std::optional无显式快知道可能失败
std::expected自定义 E显式快知道失败原因

单子操作速查 ​

操作操作对象返回类型用途
and_then(f)成功值expected链接可能失败的操作
transform(f)成功值普通值→自动包装链接不会失败的转换
or_else(f)错误值expected错误恢复
transform_error(f)错误值新错误→自动包装错误类型转换

常见问题 ​

expected 和异常该怎么选?

expected 适合预期中的错误(文件不存在、格式不对、网络超时),这些是正常业务逻辑的一部分。异常适合意外的错误(内存不足、断言失败),这些是程序不应该正常遇到的。如果错误需要跨多层传播且很少发生,异常可能更合适;如果错误是常见的返回路径,expected 更高效。

expected 和 optional 什么时候用哪个?

如果调用者需要知道失败的原因,用 expected。如果只需要知道"有或没有"(比如查找操作),用 optional。expected<T, E> 可以看作是 optional<T> 的增强版,多了错误信息。

expected 有运行时开销吗?

几乎没有。expected 内部是一个联合体(union)加一个标志位,不做堆分配。和 optional 类似,它的大小是 max(sizeof(T), sizeof(E)) + 标志位 + 对齐。单子操作在编译器优化后通常没有额外开销。

适用场景 ​

  • 文件 I/O、网络操作等可能失败的操作
  • 配置解析、数据验证
  • 需要携带错误信息但不想用异常的场景
  • 链式数据处理管道(配合单子操作)

注意事项 ​

  • expected 的错误类型 E 不能是 void(用 expected<void, E> 表示无返回值操作)
  • std::unexpected 用于构造错误状态
  • value() 在无值时抛 std::bad_expected_access
  • 单子操作要求所有步骤的错误类型一致(或用 transform_error 转换)
  • expected 是 C++23 特性,需要编译器支持

总结 ​

std::expected<T, E> 是 C++23 的核心错误处理工具,语义是"成功值 T 或错误值 E"。相比异常是显式控制流,相比 optional 携带错误信息。C++23 的单子操作(and_then、transform、or_else、transform_error)让链式错误处理变得简洁。面试中要能对比 expected、optional、异常的适用场景,解释四个单子操作的区别,以及 expected 的零开销特性。