好的，让我们开始这场关于 C++23 std::expected 的“脱口秀”吧！准备好迎接一场关于现代错误处理的狂欢了吗？
C++23 std::expected：告别“手忙脚乱”，迎接优雅的错误处理！
大家好！我是你们今天的“错误处理专家”，今天我们要聊聊 C++23 中一个非常酷炫的新玩具：std::expected。
开场白：Error Code 的“血泪史”
在开始之前，我们先来回顾一下 C++ 中处理错误的“光辉历史”。长期以来，我们和 int 类型的返回值“相爱相杀”。
int doSomething() {
// 一堆逻辑
if (/* 出错了 */) {
return -1; // 错误代码
}
return 0; // 成功
}
int main() {
int result = doSomething();
if (result != 0) {
// 处理错误
std::cerr << "出错了！错误代码: " << result << std::endl;
} else {
// 一切正常
std::cout << "成功了！" << std::endl;
}
return 0;
}这种方法简单粗暴，但缺点也很明显：
- 返回值被“污染”了：返回值原本应该用来返回计算结果，现在却要兼顾错误代码，导致语义不清。
- 错误代码难以管理：不同的函数可能会使用不同的错误代码，容易混乱。
- 调用者容易忘记检查错误：如果调用者忘记检查返回值，程序可能会在错误的状态下继续运行，导致更严重的问题。
为了解决这些问题，我们又引入了异常（Exception）。
异常：优雅的“背后捅刀”？
异常机制允许我们在函数执行过程中抛出异常，然后在调用栈的某个地方捕获并处理异常。
#include <stdexcept>
#include <iostream>
int doSomething() {
if (/* 出错了 */) {
throw std::runtime_error("发生了不可描述的错误！");
}
return 42;
}
int main() {
try {
int result = doSomething();
std::cout << "结果是: " << result << std::endl;
} catch (const std::exception& e) {
std::cerr << "捕获到异常: " << e.what() << std::endl;
}
return 0;
}异常机制的优点是：
- 错误处理与业务逻辑分离：代码更清晰。
- 强制错误处理：如果异常没有被捕获，程序会终止。
但是，异常也有一些缺点：
- 性能开销：异常处理的开销比较大，尤其是在频繁抛出异常的情况下。
- 控制流复杂：异常会导致控制流跳转，难以预测。
- 异常安全问题：编写异常安全的代码比较困难。
因此，在某些场景下，我们可能需要一种更轻量级、更可控的错误处理方式。
std::expected：闪亮登场！
std::expected 是 C++23 引入的一个模板类，它可以用来表示一个可能成功或失败的结果。它类似于 std::optional，但 std::expected 在失败时可以携带错误信息。
#include <expected>
#include <iostream>
#include <string>
std::expected<int, std::string> divide(int a, int b) {
if (b == 0) {
return std::unexpected("除数不能为 0！");
}
return a / b;
}
int main() {
auto result = divide(10, 2);
if (result) {
std::cout << "结果是: " << *result << std::endl;
} else {
std::cerr << "出错了: " << result.error() << std::endl;
}
auto result2 = divide(10, 0);
if (result2) {
std::cout << "结果是: " << *result2 << std::endl;
} else {
std::cerr << "出错了: " << result2.error() << std::endl;
}
return 0;
}在这个例子中，divide 函数返回一个 std::expected<int, std::string> 对象。如果除数不为 0，则返回一个包含计算结果的 std::expected 对象；否则，返回一个包含错误信息的 std::expected 对象。
std::expected 的优势：
- 明确的错误处理：
std::expected强制调用者处理错误，避免了忘记检查错误的问题。 - 轻量级：
std::expected的开销比异常小，适合对性能要求较高的场景。 - 可控的控制流：
std::expected不会导致控制流跳转，更容易预测。 - 类型安全：
std::expected可以携带任意类型的错误信息，提高了类型安全性。
std::expected 的基本用法：
- 定义
std::expected<T, E>其中，T 是成功时的类型，E 是失败时的类型。
- 构造
std::expected<int, std::string> result1 = 42; // 成功
std::expected<int, std::string> result2 = std::unexpected("出错了！"); // 失败- 检查是否成功
if (result) { // 如果成功，返回 true
// ...
} else { // 如果失败，返回 false
// ...
}- 获取成功时的值
int value = *result; // 如果失败，会抛出异常
int value = result.value(); // 如果失败，会抛出异常
int value = result.value_or(0); // 如果失败，返回默认值 0- 获取失败时的错误信息
std::string error = result.error(); // 获取错误信息- 转换
std::optional<int> opt = result.transform([](int x) { return x * 2; }).value_or(std::nullopt);std::expected 的高级用法：
- 自定义错误类型
enum class ErrorCode {
InvalidInput,
OutOfMemory,
FileNotFound
};
std::expected<int, ErrorCode> doSomething() {
if (/* 输入无效 */) {
return std::unexpected(ErrorCode::InvalidInput);
}
// ...
return 42;
}
int main() {
auto result = doSomething();
if (result) {
std::cout << "结果是: " << *result << std::endl;
} else {
switch (result.error()) {
case ErrorCode::InvalidInput:
std::cerr << "输入无效！" << std::endl;
break;
case ErrorCode::OutOfMemory:
std::cerr << "内存不足！" << std::endl;
break;
case ErrorCode::FileNotFound:
std::cerr << "文件未找到！" << std::endl;
break;
}
}
return 0;
}- 链式调用
#include <expected>
#include <iostream>
#include <string>
std::expected<int, std::string> parseInt(const std::string& str) {
try {
return std::stoi(str);
} catch (const std::exception& e) {
return std::unexpected(e.what());
}
}
std::expected<int, std::string> divide(int a, int b) {
if (b == 0) {
return std::unexpected("除数不能为 0！");
}
return a / b;
}
int main() {
auto result = parseInt("10")
.and_then([](int x) { return divide(20, x); })
.and_then([](int x) { return x * 2; });
if (result) {
std::cout << "结果是: " << *result << std::endl;
} else {
std::cerr << "出错了: " << result.error() << std::endl;
}
auto result2 = parseInt("abc")
.and_then([](int x) { return divide(20, x); })
.and_then([](int x) { return x * 2; });
if (result2) {
std::cout << "结果是: " << *result2 << std::endl;
} else {
std::cerr << "出错了: " << result2.error() << std::endl;
}
return 0;
}在这个例子中，我们使用 and_then 函数将多个 std::expected 对象链接起来，形成一个链式调用。如果其中任何一个函数返回失败，整个链式调用都会失败。
- 与
std::optional配合使用
#include <expected>
#include <optional>
#include <iostream>
#include <string>
std::expected<std::optional<int>, std::string> findValue(int key) {
// 模拟从数据库中查找值
if (key == 42) {
return std::optional<int>(123); // 找到值
} else {
return std::optional<int>(); // 没有找到值
}
}
int main() {
auto result = findValue(42);
if (result) {
if (*result) {
std::cout << "找到了值: " << **result << std::endl;
} else {
std::cout << "没有找到值" << std::endl;
}
} else {
std::cerr << "出错了: " << result.error() << std::endl;
}
auto result2 = findValue(100);
if (result2) {
if (*result2) {
std::cout << "找到了值: " << **result2 << std::endl;
} else {
std::cout << "没有找到值" << std::endl;
}
} else {
std::cerr << "出错了: " << result2.error() << std::endl;
}
return 0;
}在这个例子中，findValue 函数返回一个 std::expected<std::optional<int>, std::string> 对象。如果查找成功，则返回一个包含 std::optional<int> 对象的 std::expected 对象；否则，返回一个包含错误信息的 std::expected 对象。std::optional<int> 用于表示可能存在或不存在的值。
何时使用 std::expected？
- 需要明确的错误处理：当我们需要强制调用者处理错误时，
std::expected是一个很好的选择。 - 对性能要求较高：当性能是关键因素时，
std::expected比异常更适合。 - 需要可控的控制流：当我们需要预测控制流时，
std::expected比异常更可控。 - 需要类型安全的错误信息：当我们需要携带任意类型的错误信息时，
std::expected提供了更好的类型安全性。
std::expected 与其他错误处理方式的比较：
| 特性 | 返回错误代码 | 异常 | std::expected |
|---|---|---|---|
| 明确的错误处理 | 否 | 半强制 | 是 |
| 性能 | 高 | 低 | 中 |
| 控制流 | 简单 | 复杂 | 简单 |
| 类型安全 | 低 | 高 | 高 |
| 适用场景 | 简单场景 | 复杂、不常出错 | 需要明确错误处理、性能敏感 |
总结：
std::expected 是 C++23 引入的一个非常有用的工具，它可以帮助我们编写更清晰、更健壮、更高效的代码。它提供了一种明确、轻量级、可控的错误处理方式，可以替代传统的错误代码和异常机制，尤其是在对性能要求较高的场景下。
希望今天的“脱口秀”能让你对 std::expected 有更深入的了解。现在，你可以拿起键盘，开始尝试使用 std::expected 来改善你的代码了！
温馨提示：
std::expected是 C++23 的新特性，需要使用支持 C++23 的编译器才能编译。- 在使用
std::expected时，需要仔细考虑错误类型的设计，选择合适的错误类型可以提高代码的可读性和可维护性。 std::expected并非万能的，在某些场景下，异常可能更适合。我们需要根据具体的场景选择合适的错误处理方式。
谢谢大家！希望下次还能有机会和大家一起探讨 C++ 的新特性！