Optional 与 Monadic 操作

std::optional 是 C++17 引入的一个核心词汇类型,用于表达"一个值可能存在,也可能不存在"。它将"也许为空"的语义直接编码进类型系统,消除了魔术值、空指针和异常滥用。C++23 进一步为它添加了 monadic 操作,使链式处理变得优雅而安全。

std::optional 基础

std::optional<T> 是一个包装器:它要么持有一个 T 类型的值,要么处于"空"状态。你可以把它想象成一个最多容纳一个元素的容器。

创建 optional

#include <optional>
#include <string>

// 持有一个值
std::optional<int> age = 25;
std::optional<std::string> name = "Alice";

// 空状态 —— 明确表示"没有值"
std::optional<int> no_age = std::nullopt;
std::optional<double> no_score;  // 默认构造也是空

// 从函数返回
std::optional<int> parse_int(std::string_view s) {
    int value{};
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), value);
    if (ec == std::errc{} && ptr == s.data() + s.size()) {
        return value;  // 隐式转换为 optional<int>
    }
    return std::nullopt;  // 解析失败
}

访问值

std::optional<int> result = parse_int("42");

// 方式 1: 布尔检查 + 解引用
if (result) {
    std::println("解析成功: {}", *result);
}

// 方式 2: has_value() + value()
if (result.has_value()) {
    std::println("值为: {}", result.value());  // 空时抛 bad_optional_access
}

// 方式 3: value_or() —— 提供默认值
int final_value = result.value_or(0);  // 空时返回 0
std::println("最终值: {}", final_value);

就地构造(避免拷贝)

struct Connection {
    Connection(std::string host, int port) : host_(std::move(host)), port_(port) {}
    std::string host_;
    int port_;
};

// 使用 std::in_place 直接在 optional 内部构造对象
std::optional<Connection> conn{std::in_place, "localhost", 8080};

// 或使用 emplace
std::optional<Connection> conn2;
conn2.emplace("192.168.1.1", 3306);  // 直接在内部构造,无需移动

提示:std::optional 不使用堆分配。值直接存储在 optional 对象内部(类似于 union + bool 标志位),因此它几乎没有运行时开销。

为什么用 optional

在没有 std::optional 的年代,C++ 程序员为表达"可能没有值"发明了许多 ad-hoc 方案,每一种都有明显缺陷:

// 旧风格 1:返回 -1 表示"未找到"
int find_index(const std::vector<int>& v, int target);
// 问题:-1 是个合法的数组索引吗?调用者必须记住检查

// 旧风格 2:通过指针返回,nullptr 表示失败
User* find_user(int id);
// 问题:谁负责释放内存?返回的指针有效期多久?

// 旧风格 3:抛异常
int parse(const std::string& s);  // 失败时抛 std::invalid_argument
// 问题:用异常处理"可预期"的情况,代价高、意图不明确

// 现代风格:语义清晰,类型安全
std::optional<std::size_t> find_index(const std::vector<int>& v, int target);
std::optional<User> find_user(int id);
std::optional<int> parse(const std::string& s);

std::optional 的优势一目了然:

  • 类型系统显式表达——看到返回类型就知道它可能为空,不需要查阅文档
  • 无魔术值——不再需要记住 -1、0、""、INT_MAX 等特殊含义
  • 不滥用异常——"找不到"不是异常情况,是正常的业务逻辑分支
  • 自文档化 API——函数签名本身就是最好的文档

optional 作为返回值

这是 std::optional 最常见的用法:当函数"可能成功也可能失败"但失败不是异常时,返回 optional。

数据库查找

struct User {
    int id;
    std::string name;
    std::string email;
};

class UserRepository {
public:
    std::optional<User> find_by_id(int id) const {
        auto it = users_.find(id);
        if (it != users_.end()) {
            return it->second;
        }
        return std::nullopt;  // 用户不存在 —— 正常情况,不是错误
    }

    std::optional<User> find_by_email(std::string_view email) const {
        for (const auto& [id, user] : users_) {
            if (user.email == email) return user;
        }
        return std::nullopt;
    }

private:
    std::unordered_map<int, User> users_;
};

配置解析

class Config {
public:
    // 键可能存在也可能不存在
    std::optional<std::string> get_string(std::string_view key) const {
        auto it = data_.find(std::string(key));
        if (it != data_.end()) return it->second;
        return std::nullopt;
    }

    std::optional<int> get_int(std::string_view key) const {
        auto str = get_string(key);
        if (!str) return std::nullopt;
        return parse_int(*str);  // 复用前面的 parse_int
    }

private:
    std::unordered_map<std::string, std::string> data_;
};

// 使用
Config config = load_config("app.toml");
int port = config.get_int("server.port").value_or(8080);
std::string host = config.get_string("server.host").value_or("0.0.0.0");

安全的类型转换

// 将字符串安全地转换为枚举
enum class Color { Red, Green, Blue };

std::optional<Color> parse_color(std::string_view s) {
    if (s == "red")   return Color::Red;
    if (s == "green") return Color::Green;
    if (s == "blue")  return Color::Blue;
    return std::nullopt;  // 无法识别的颜色名
}

// 调用方
auto color = parse_color(user_input);
if (!color) {
    std::println(stderr, "无效颜色: '{}'", user_input);
    return;
}
apply_color(*color);

Monadic 操作 (C++23)

C++23 为 std::optional 增加了三个 monadic 成员函数,让我们能以函数式风格进行链式操作,避免层层嵌套的 if 判断。

and_then(f) —— 扁平映射

当 optional 有值时调用 f,f 本身返回一个 optional(可能成功也可能失败)。如果原始 optional 为空,直接返回空。

// f 的签名: T -> std::optional<U>

std::optional<std::string> get_email(const User& user) {
    if (user.email.empty()) return std::nullopt;
    return user.email;
}

// and_then: optional<User> 经过 get_email 变为 optional<string>
std::optional<std::string> email = find_user(42).and_then(get_email);
// 如果 find_user 返回空 → email 为空
// 如果用户存在但邮箱为空 → email 也为空
// 只有用户存在且邮箱非空 → email 有值

transform(f) —— 值映射

当 optional 有值时调用 f,f 返回普通值(不是 optional),结果自动包装成 optional。如果原始 optional 为空,直接返回空。

// f 的签名: T -> U(不是 optional!)

std::string to_upper(std::string s) {
    std::ranges::transform(s, s.begin(), ::toupper);
    return s;
}

// transform: optional<string> 经过 to_upper 变为 optional<string>
auto upper_email = find_user(42)
    .and_then(get_email)
    .transform(to_upper);
// 有值时变为大写;空时仍为空

or_else(f) —— 空值恢复

当 optional 为空时调用 f,f 返回同类型的 optional(提供一个替代值或执行副作用)。如果原始 optional 有值,直接返回原值。

// f 的签名: () -> std::optional<T>

std::optional<std::string> get_cached_email(int user_id);
std::optional<std::string> fetch_email_from_db(int user_id);

// or_else: 缓存未命中时尝试数据库
auto email = get_cached_email(user_id)
    .or_else([&] { return fetch_email_from_db(user_id); });

// 也可用于日志记录
auto result = find_user(id)
    .or_else([&]() -> std::optional<User> {
        std::println(stderr, "警告: 用户 {} 未找到", id);
        return std::nullopt;  // 记录日志后仍返回空
    });

记忆技巧:

  • and_then:有值就继续(但下一步也可能失败)—— f 返回 optional
  • transform:有值就变换(变换一定成功)—— f 返回普通值
  • or_else:为空就补救 —— f 返回 optional

链式操作

monadic 操作的真正威力在于组合。我们可以构建处理管道,让数据沿着"铁轨"流动——有值时继续前进,为空时短路跳过。

对比:传统 if-else vs monadic 链

// ===== 传统写法:层层嵌套的 if =====
std::optional<std::string> get_formatted_address_old(int user_id) {
    auto user = find_user(user_id);
    if (!user) return std::nullopt;

    auto address = get_address(*user);
    if (!address) return std::nullopt;

    auto validated = validate_address(*address);
    if (!validated) return std::nullopt;

    return format_address(*validated);
}

// ===== C++23 monadic 写法:清晰的管道 =====
std::optional<std::string> get_formatted_address(int user_id) {
    return find_user(user_id)
        .and_then(get_address)       // User -> optional<Address>
        .and_then(validate_address)  // Address -> optional<Address>
        .transform(format_address);  // Address -> string
}

实际案例:配置加载管道

struct ServerConfig {
    std::string host;
    int port;
    bool tls;
};

std::optional<std::string> read_env(std::string_view var);
std::optional<std::string> read_file(std::string_view path);
std::optional<ServerConfig> parse_config(std::string_view json);
ServerConfig with_defaults(ServerConfig cfg);

// 管道:环境变量 → 配置文件路径 → 读取文件 → 解析 → 填充默认值
auto config = read_env("APP_CONFIG_PATH")
    .and_then(read_file)          // 路径 → 文件内容
    .and_then(parse_config)       // JSON文本 → ServerConfig
    .transform(with_defaults)     // 填充缺失字段
    .value_or(ServerConfig{"localhost", 8080, false});  // 兜底默认

Railway-Oriented Programming

这种模式在函数式编程中被称为"铁路导向编程":数据沿两条轨道流动——"有值轨道"和"空轨道"。每一步操作只在"有值轨道"上执行,一旦某步产生空值,后续步骤全部跳过。

// 完整示例:订单处理管道
struct Order { int id; int user_id; double amount; };
struct Receipt { std::string confirmation; };

std::optional<Order> find_order(int order_id);
std::optional<Order> verify_payment(Order order);
std::optional<Order> check_inventory(Order order);
Receipt generate_receipt(const Order& order);

auto process_order(int order_id) {
    return find_order(order_id)          // 查找订单
        .and_then(verify_payment)        // 验证付款(可能失败)
        .and_then(check_inventory)       // 检查库存(可能失败)
        .transform(generate_receipt)     // 生成收据(一定成功)
        .or_else([&]() -> std::optional<Receipt> {
            log_failure(order_id);       // 任何一步失败时记录
            return std::nullopt;
        });
}

注意事项

optional 不支持引用类型

// 编译错误!optional<T&> 不被允许
// std::optional<int&> ref = some_int;

// 替代方案 1:使用指针
std::optional<int*> ptr_to_int;

// 替代方案 2:使用 reference_wrapper
#include <functional>
std::optional<std::reference_wrapper<const std::string>> find_name(int id);

// C++26 可能会引入 optional<T&> 支持(P2988)

避免 optional<bool>

// 糟糕:三种状态令人困惑
std::optional<bool> is_admin(int user_id);
// nullopt = 用户不存在? false = 非管理员? true = 管理员?
// 调用者很容易搞混:if (is_admin(id)) 在 nullopt 时也是 false!

// 更好的做法:使用枚举显式表达
enum class AdminStatus { NotFound, Regular, Admin };
AdminStatus get_admin_status(int user_id);

警告:不要对 optional<bool> 直接使用布尔判断!if (opt) 检查的是"是否有值",而不是"值是否为 true"。这会导致细微且难以发现的 bug。如果确实需要三态逻辑,请使用枚举或 std::tribool。

性能特征

// optional 的内存布局(概念模型):
// struct optional<T> {
//     alignas(T) std::byte storage[sizeof(T)];  // 值的存储空间
//     bool has_value;                            // 标志位
// };

// 关键性能事实:
// 1. 没有堆分配 —— 值直接内联存储
// 2. sizeof(optional<int>) == 8(4字节int + 1字节flag + 3字节对齐填充)
// 3. 对于小类型,optional 的开销仅为一个 bool 的额外空间
// 4. 编译器通常能优化掉 optional 的间接层

static_assert(sizeof(std::optional<int>) == 8);
static_assert(sizeof(std::optional<double>) == 16);
static_assert(sizeof(std::optional<char>) == 2);

性能提示:对于大对象,std::optional<BigObj> 会在栈上分配完整对象空间(即使为空也占用那么多字节)。如果对象非常大且大部分时间为空,考虑使用 std::unique_ptr<BigObj> 代替——它只占一个指针大小,代价是多了一次堆分配。

本章小结

  • std::optional<T> 在类型系统中显式编码"可能为空"的语义,替代魔术值、空指针和滥用异常
  • 创建方式:直接赋值、std::nullopt、std::in_place;访问方式:*opt、value()、value_or()
  • 最适合作为函数返回值——用于"查找可能失败"、"解析可能无效"等场景
  • C++23 monadic 操作:and_then(扁平映射)、transform(值映射)、or_else(空值恢复)
  • 链式 monadic 操作实现"铁路导向编程"——消除嵌套 if,代码清晰表达数据流向
  • 注意:不支持引用类型、避免 optional<bool>、无堆分配但占满对象空间