随意聊聊optional：一种不计划表达为什么出错的错误处理
这个仓库已经开源！现代化 C++（C++11/14/17/20）从基础到进阶的系统教程都在这里，力争做一条完备的现代 C++ 学习路径！欢迎各位大佬前来参观，喜欢的话点个⭐！
Github 一键直达: git clone https://github.com/Awesome-Embedded-Learning-Studio/Tutorial_AwesomeModernCPP
看看超酷的新网站：https://awesome-embedded-learning-studio.github.io/Tutorial_AwesomeModernCPP/
在上一篇里我们梳理了 C++ 错误处理的演进路线，最后提到std::optional可以用于表达"可能失败的操作"。这一篇我们就来深入看看，optional在错误处理场景下到底好不好用、该怎么用、以及什么时候不该用它。
先说结论：std::optional是一把精确的手术刀，不是瑞士军刀。它在特定场景下非常好用，但如果拿来当通用的错误处理工具，你会发现自己到处都在猜"为什么返回了 nullopt"。
optional 的语义：成功或无值
std::optional<T>的语义非常直白——它要么持有一个T类型的值，要么是空的（std::nullopt）。把它用在错误处理上，就是"成功返回值，失败返回空"：
#include<optional>#include<string>/// 尝试将字符串解析为整数，失败则返回空std::optional<int>parse_int(conststd::string&s){try{std::size_t pos=0;intvalue=std::stoi(s,&pos);if(pos!=s.size()){returnstd::nullopt;// 有多余字符，解析不完整}returnvalue;}catch(...){returnstd::nullopt;}}这种写法最大的好处是语义在类型里。函数签名std::optional<int>就已经告诉调用方"这个函数可能不返回值"，你不需要查文档、不需要记约定——类型本身就是文档。调用方拿到返回值后，第一件事自然是检查有没有值：
autoresult=parse_int("42");if(result){std::cout<<"Got: "<<*result<<"\n";}else{std::cout<<"Parse failed\n";}适合 optional 的场景
optional最适合的场景有一个共同特征：失败是正常情况的一部分，而且调用方不需要知道失败的具体原因。
场景一：查找操作
查找是最经典的 optional 场景。从容器中查找一个元素，找不到不是"错误"，而是"没找到"——这个区别很重要。你不需要告诉调用方"为什么没找到"，因为原因只有一个：不存在。
#include<unordered_map>#include<optional>#include<string>structUser{std::string name;intage;};classUserRegistry{public:std::optional<User>find(intid)const{autoit=users_.find(id);if(it!=users_.end()){returnit->second;}returnstd::nullopt;}voidadd(intid,User user){users_[id]=std::move(user);}private:std::unordered_map<int,User>users_;};// 使用UserRegistry registry;registry.add(1,User{"Alice",30});autouser=registry.find(1);if(user){std::cout<<user->name<<"\n";// Alice}automissing=registry.find(99);// missing 是 nullopt，但这是正常情况，不是错误场景二：解析操作
从外部输入（配置文件、用户输入、网络数据）中解析信息，失败是家常便饭。如果调用方只需要知道"解析成功了吗"，optional就够了：
#include<optional>#include<string>#include<charconv>#include<system_error>/// 从字符串视图解析浮点数std::optional<double>parse_double(std::string_view sv){doublevalue=0.0;auto[ptr,ec]=std::from_chars(sv.data(),sv.data()+sv.size(),value);if(ec==std::errc{}&&ptr==sv.data()+sv.size()){returnvalue;}returnstd::nullopt;}// 使用autov1=parse_double("3.14");// optional(3.14)autov2=parse_double("hello");// nulloptautov3=parse_double("3.14abc");// nullopt（有多余字符）场景三：带默认值的场景
当操作失败时你有合理的默认值，optional的value_or可以让代码非常简洁：
#include<optional>#include<string>#include<cstdlib>std::optional<std::string>get_env(conststd::string&key){constchar*val=std::getenv(key.c_str());if(val)returnstd::string(val);returnstd::nullopt;}// 使用 value_or 提供默认值std::string log_level=get_env("LOG_LEVEL").value_or("INFO");intmax_threads=parse_int(get_env("MAX_THREADS").value_or("4")).value_or(4);场景四：缓存查找
缓存命中就返回值，未命中就返回空——这不需要任何错误信息：
template<typenameKey,typenameValue>classSimpleCache{public:std::optional<Value>get(constKey&key)const{autoit=cache_.find(key);if(it!=cache_.end()&&!it->second.expired){returnit->second.data;}returnstd::nullopt;}voidput(constKey&key,Value value){cache_[key]={std::move(value),false};}private:structEntry{Value data;boolexpired=false;};std::unordered_map<Key,Entry>cache_;};不适合 optional 的场景
optional的致命局限是不携带错误信息。当调用方需要知道"为什么失败"时，optional就不够用了。
需要区分多种错误类型
// 不好：三种不同的失败原因被揉成了一个 nulloptstd::optional<Config>load_config(conststd::string&path){autof=open_file(path);if(!f)returnstd::nullopt;// 文件不存在？权限不够？autocontent=read_content(f);if(content.empty())returnstd::nullopt;// 空文件？读取出错？returnparse_config(content);// 解析失败也是 nullopt}autocfg=load_config("app.cfg");if(!cfg){// 我现在该怎么办？文件不存在要创建，格式错误要报告，权限不够要提权// 但我只知道"失败了"，什么都区分不了}这种情况应该用std::expected<Config, ConfigError>或者一个携带错误信息的返回结构体。
需要错误传播链
当你需要把多个可能失败的操作串联起来，并且在链的末端知道是哪一步失败了，optional会让调试变得非常痛苦。每一步失败都变成nullopt，到了最后你只知道"某个地方失败了"，但不知道是哪里。
C++23 的 monadic 操作
C++23 为std::optional新增了三个 monadic 成员函数：and_then、transform、or_else。这三个操作让optional的链式处理变得优雅得多。
and_then：链接可能失败的操作
and_then接受一个函数，该函数接受optional内部的值并返回一个新的optional。如果原始optional为空，直接返回空，不调用函数：
#include<optional>#include<string>#include<iostream>structUserProfile{std::string name;intage;};std::optional<UserProfile>fetch_from_cache(intuser_id){// 模拟：ID 1 在缓存中if(user_id==1)returnUserProfile{"Alice",30};returnstd::nullopt;}std::optional<UserProfile>fetch_from_server(intuser_id){// 模拟：ID 1 和 2 在服务器上if(user_id==1||user_id==2)returnUserProfile{"Bob",25};returnstd::nullopt;}std::optional<int>extract_age(constUserProfile&profile){if(profile.age>0)returnprofile.age;returnstd::nullopt;}intmain(){intuser_id=1;// C++23 monadic 链autoage_next=fetch_from_cache(user_id).or_else([user_id](){returnfetch_from_server(user_id);}).and_then(extract_age).transform([](intage){returnage+1;});if(age_next){std::cout<<"Next year age: "<<*age_next<<"\n";}}对比一下没有 monadic 操作时的写法：
// C++20 风格：嵌套的 if/elseautoprofile=fetch_from_cache(user_id);if(!profile){profile=fetch_from_server(user_id);}std::optional<int>age_next;if(profile){autoage=extract_age(*profile);if(age){age_next=*age+1;}}monadic 版本把"正常路径"放在一条链上，每个步骤都清楚地表达了"拿到数据后做什么"。错误传播是自动的——任何一步返回空，后续步骤全部跳过。
transform：对值做变换
transform和and_then的区别在于，传入transform的函数返回一个普通值（不是optional），transform会自动把结果包回optional：
// transform：返回值会被自动包装成 optionalautoupper_name=fetch_from_cache(1).transform([](constUserProfile&p)->std::string{std::string s=p.name;for(auto&c:s)c=std::toupper(c);returns;});// upper_name 的类型是 std::optional<std::string>一句话区分：and_then用于"下一步可能失败"的操作（函数返回optional），transform用于"下一步一定成功"的变换（函数返回普通值）。
or_else：提供备选方案
or_else在optional为空时调用传入的函数，通常用于提供回退方案或记录日志：
autoresult=fetch_from_cache(user_id).or_else([user_id](){std::cerr<<"Cache miss for user "<<user_id<<"\n";returnfetch_from_server(user_id);}).or_else([](){std::cerr<<"Server also failed, using default\n";returnstd::optional<UserProfile>(UserProfile{"Default",0});});与 Rust Option 的对比
用过 Rust 的朋友可能觉得 C++ 的optional有点"不够力"。确实如此，主要体现在两个方面：
Rust 的Option<T>有编译器的#[must_use]检查——如果你忽略了一个Option返回值，编译器会发出警告。C++ 的std::optional没有这个保证，虽然你可以用[[nodiscard]]标注返回类型，但标准库并没有这么做。
Rust 的Option<T>有一个强大的?操作符用于错误传播。在函数里写let val = might_fail()?;，如果might_fail返回None，函数立即返回None。C++ 没有这么优雅的语法，你需要手动检查，或者用宏来模拟（比如前面提到的TRY宏）。
不过 C++23 的 monadic 操作已经在很大程度上弥补了这个差距——链式调用虽然不如?操作符简洁，但已经足够好用了。
通用示例
最后来看一个比较完整的例子——配置文件解析，展示optional在真实场景下的使用方式：
#include<optional>#include<string>#include<string_view>#include<fstream>#include<sstream>#include<iostream>#include<charconv>structServerConfig{std::string host;intport;inttimeout_ms;};classConfigParser{public:std::optional<ServerConfig>parse(std::string_view content){ServerConfig cfg;cfg.host=extract_field(content,"host").value_or("localhost");autoport_str=extract_field(content,"port");if(port_str){autop=parse_int(*port_str);if(!p||*p<1||*p>65535){returnstd::nullopt;// 端口无效}cfg.port=*p;}else{cfg.port=8080;}autotimeout_str=extract_field(content,"timeout_ms");if(timeout_str){autot=parse_int(*timeout_str);if(!t||*t<0){returnstd::nullopt;}cfg.timeout_ms=*t;}else{cfg.timeout_ms=5000;}returncfg;}private:staticstd::optional<std::string>extract_field(std::string_view content,std::string_view key){std::string search=std::string(key)+"=";autopos=content.find(search);if(pos==std::string_view::npos)returnstd::nullopt;autostart=pos+search.size();autoend=content.find('\n',start);if(end==std::string_view::npos)end=content.size();returnstd::string(content.substr(start,end-start));}staticstd::optional<int>parse_int(std::string_view sv){intvalue=0;auto[ptr,ec]=std::from_chars(sv.data(),sv.data()+sv.size(),value);if(ec==std::errc{}&&ptr==sv.data()+sv.size()){returnvalue;}returnstd::nullopt;}};intmain(){std::string config_text="host=192.168.1.1\nport=3000\ntimeout_ms=10000\n";ConfigParser parser;autocfg=parser.parse(config_text);if(cfg){std::cout<<"Host: "<<cfg->host<<", Port: "<<cfg->port<<", Timeout: "<<cfg->timeout_ms<<"ms\n";}else{std::cout<<"Failed to parse config\n";}}这个例子展示了optional的典型用法：查找字段时用optional表示"可能不存在"，解析数值时用optional表示"可能失败"，用value_or提供默认值。代码清晰，正常路径和失败路径一目了然。
小结
std::optional在错误处理领域的定位很明确：它适合那些"失败不需要原因"的简单场景——查找、解析、缓存、默认值。如果场景需要区分错误类型、需要错误传播链、或者需要在链末端诊断问题，就该换expected或者其他更重的方案了。
C++23 的 monadic 操作（and_then、transform、or_else）让optional的链式处理变得优雅，大大减少了嵌套的if/else代码。如果你的项目还在 C++17，手写几个辅助函数也能达到类似效果。
下一篇我们就来看看std::expected<T, E>—— 当你需要"值 + 错误信息"时，它是怎么做的。
参考资源
- cppreference: std::optional
- Monadic operations for std::optional (C++23)
- P0798R8 - Monadic operations for std::expected