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 增加了单子操作,允许把多个可能失败的操作链接成管道,错误自动传播,不需要手动检查每一步。
基本示例
#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 的零开销特性。