15. std::optional与错误处理：函数式错误处理、Monad思想

错误处理，是每个C++程序员都绕不开的话题。我早年写代码时，习惯用返回-1或者nullptr来表示失败。后来项目大了，这种「约定式」的错误处理让我吃了不少苦头——调用方忘了检查返回值，程序就悄悄跑偏了。

直到C++17带来了std::optional，我才觉得「嗯，这才像话」。它把「可能有值，也可能没有」这个语义，直接写进了类型系统里。你想想看，一个函数返回optional<int>，调用者一看就知道：这玩意儿可能为空，我得处理一下。

15.1 为什么需要optional？

传统的错误处理方式，说白了就是「用特殊值表示失败」。比如：

int divide(int a, int b) {
    if (b == 0) return -1;  // 用-1表示除零错误
    return a / b;
}

这有什么问题？调用方可能忘了检查返回值，直接把-1当正常结果用了。更糟糕的是，如果a/b的结果恰好就是-1呢？你分不清这是正常结果还是错误标志。

std::optional把这个问题从根本上解决了：

std::optional<int> divide(int a, int b) {
    if (b == 0) return std::nullopt;  // 明确表示无值
    return a / b;                     // 正常返回
}

调用方必须显式检查：

auto result = divide(10, 0);
if (result.has_value()) {
    std::cout << "结果是: " << result.value() << "\n";
} else {
    std::cout << "除零错误!\n";
}

我个人习惯用if (result)这种更简洁的写法，它等价于has_value()。

15.2 optional的常用操作

咱们快速过一下常用的API，都是些很直观的东西：

操作	说明	示例
构造	创建optional对象	std::optional<int> o1 = 42;
空值	表示无值	std::optional<int> o2 = std::nullopt;
检查	判断是否有值	if (o1) { ... }
取值	获取内部值	o1.value() 或 *o1
默认值	无值时返回默认值	o1.value_or(0)
重置	清空值	o1.reset()

这里有个小坑：用*o1取值时，如果optional为空，行为是未定义的。我曾经在代码review时看到有人直接*opt而不检查，结果线上偶发崩溃。所以，要么用value()（它会抛std::bad_optional_access异常），要么先检查再取值。

15.3 函数式错误处理：链式调用

这才是optional真正发光的地方。你想想看，如果有一连串的操作，每一步都可能失败，传统写法会变成什么样子？

// 传统写法：嵌套检查
auto a = parse_int("42");
if (a.has_value()) {
    auto b = compute(a.value());
    if (b.has_value()) {
        auto c = format(b.value());
        if (c.has_value()) {
            std::cout << c.value() << "\n";
        }
    }
}

这代码看着就头疼，对吧？缩进越来越深，逻辑被层层包裹。函数式风格可以把它拍平：

// 函数式写法：链式调用
parse_int("42")
    .and_then(compute)
    .and_then(format)
    .and_then([](const std::string& s) {
        std::cout << s << "\n";
        return std::optional<std::string>{s};
    });

and_then是C++23引入的，它的作用很简单：如果optional有值，就把值传给回调函数，返回新的optional；如果没值，直接返回空optional。这就把「检查-传递」的逻辑封装起来了。

15.4 Monad思想：optional背后的哲学

说到Monad，很多人觉得这是个高深的概念。其实没那么玄乎。你想想看，optional就像一个盒子：

• 盒子里可能有值，也可能没有
• 你想对盒子里的值做操作，但又不想手动开箱、检查、再装箱
• Monad就是帮你自动完成这套流程的工具

在C++里，optional算是一个简单的Monad实现。它提供了三个核心操作：

1. 构造（return）：把普通值装进盒子——std::optional<int>(42)
2. 变换（fmap）：对盒子里的值做映射——opt.transform(func)
3. 展平（bind）：处理返回盒子的函数——opt.and_then(func)

我用一个简单的例子来说明：

// transform：值变换，结果还在盒子里
std::optional<int> opt = 42;
auto doubled = opt.transform([](int x) { return x * 2; });
// doubled 是 optional<int>{84}

// and_then：函数返回optional，避免嵌套
auto safe_sqrt = [](int x) -> std::optional<double> {
    if (x < 0) return std::nullopt;
    return std::sqrt(x);
};
auto result = opt.and_then(safe_sqrt);
// result 是 optional<double>{6.48}

区别在哪？transform的回调返回普通值，框架帮你装箱；and_then的回调自己返回optional，框架只负责传递。如果你用transform去调用一个返回optional的函数，就会得到optional<optional<T>>——两层盒子，很尴尬。

15.5 实战：用optional重构错误处理

咱们看一个实际例子。假设你要写一个配置解析器，从字符串里读端口号：

// 传统风格：到处是if-else
int parse_port(const std::string& input) {
    if (input.empty()) return -1;
    try {
        int port = std::stoi(input);
        if (port < 0 || port > 65535) return -1;
        return port;
    } catch (...) {
        return -1;
    }
}

// 调用方
int port = parse_port("8080");
if (port == -1) {
    // 处理错误
}

用optional重写：

std::optional<int> parse_port(const std::string& input) {
    if (input.empty()) return std::nullopt;
    try {
        int port = std::stoi(input);
        if (port < 0 || port > 65535) return std::nullopt;
        return port;
    } catch (...) {
        return std::nullopt;
    }
}

// 调用方
auto port = parse_port("8080");
if (port) {
    // 使用 port.value()
} else {
    // 处理错误
}

看起来差不多？别急，当你有多个配置项需要解析时，差距就出来了：

// 链式解析多个配置
auto config = parse_port("8080")
    .and_then([](int port) {
        return parse_host("localhost")
            .transform([port](const std::string& host) {
                return Config{host, port};
            });
    });

每个解析步骤都返回optional，错误自动传播。如果parse_port失败，后面的parse_host根本不会执行。这就是Monad的威力——你写的是「正常路径」的逻辑，错误处理被抽象掉了。

15.6 避坑指南

我用optional这些年，踩过几个坑，分享给你：

15.7 知识体系总览

下面这张图总结了本章的核心逻辑：

这张图把optional的三大块串起来了：基本操作是基础，函数式操作是进阶，Monad思想是背后的设计哲学。三者层层递进，理解了这个脉络，你就能灵活运用了。

---

好了，关于std::optional和函数式错误处理，就聊到这儿。记住一句话：optional不是银弹，但它能让你的错误处理代码更清晰、更安全。下次写可能失败的函数时，试试用optional替代特殊返回值，你会喜欢上这种感觉的。