Optional 实现详解
概述
Optional<T>是一个可能包含值也可能为空的容器，用于显式表达"值可能不存在"的语义。它解决了传统方案的缺陷：用 -1 表示无效 ID、用 nullptr 表示无效指针、用空字符串表示无值——这些都需要额外约定且容易出错。
Optional<T>的核心挑战与Vector<T>相同：需要一块内存，但对象不一定存在。我们必须手动控制对象的构造和析构时机。
设计要点
1. 使用 union 管理存储
union{T value_;};当 T 有非 trivial 构造/析构时，union 不会自动调用它们。这让我们可以：
- 在 Optional 为空时不构造 T
- 手动决定何时调用构造函数和析构函数
- 避免使用
reinterpret_cast（相比char[]方案更干净）
2. 赋值运算符的四种情况
赋值比构造复杂，因为 this 可能已有值：
| this 有值 | other 有值 | 最优操作 |
|---|---|---|
| ✓ | ✓ | 直接赋值（或析构+构造） |
| ✓ | ✗ | 析构 this |
| ✗ | ✓ | placement new |
| ✗ | ✗ | 无操作 |
3. 处理不可赋值的类型
如果 T 定义了移动构造但没有赋值运算符（如只定义了移动构造的类型），直接赋值会编译失败。解决方案是用if constexpr检查：
ifconstexpr(std::is_move_assignable_v<T>)value_=std::move(other.value_);// 直接赋值else{value_.~T();new(&value_)T(std::move(other.value_));// 析构+构造}Placement new 调用的是构造函数而非赋值运算符，所以可以绕过这个限制。
4. 移动语义的设计选择
移动构造后，源对象仍然has_value() == true，只是值处于 moved-from 状态。这与标准库行为一致：移动后的对象处于"有效但未指定"状态，而非"空"状态。
实现注意点
默认构造必须初始化
has_value_：union 成员不会自动初始化，has_value_也需要显式初始化构造函数用 placement new，不能用赋值：在拷贝/移动构造时，
value_还不存在赋值运算符分情况处理：必须检查双方的
has_value_状态，漏掉任何一个分支都会导致 bug用
if constexpr处理不可赋值类型：避免对没有赋值运算符的类型调用operator=析构前必须检查
has_value_：不能析构不存在的对象operator bool()和value_or()必须是 const：否则无法在 const 对象上使用
带注释的完整实现
#include<optional>// std::nullopt_t, std::bad_optional_access#include<type_traits>// std::is_copy_assignable_v, std::is_move_assignable_v#include<utility>// std::move, std::forwardtemplate<typenameT>classOptional{public:// ==================== 构造函数 ====================// 默认构造：空状态// 必须显式初始化 has_value_，否则是垃圾值Optional():has_value_(false){}// 从左值构造：拷贝值Optional(constT&value):value_(value),has_value_(true){}// 从右值构造：移动值Optional(T&&value):value_(std::move(value)),has_value_(true){}// 从 nullopt 构造：显式表达空的意图// 允许写 Optional<int> opt = std::nullopt;Optional(std::nullopt_t):has_value_(false){}// ==================== 拷贝/移动构造 ====================// 拷贝构造// 注意：value_ 尚不存在，必须用 placement new 而非赋值Optional(constOptional&other):has_value_(other.has_value_){if(has_value_)new(&value_)T(other.value_);}// 移动构造// 移动后 other.has_value() 仍为 true，值处于 moved-from 状态// 这是标准库的语义：移动后对象有效但状态未指定Optional(Optional&&other):has_value_(other.has_value_){if(has_value_)new(&value_)T(std::move(other.value_));}// ==================== 赋值运算符 ====================// 拷贝赋值：根据双方状态分四种情况处理Optional&operator=(constOptional&other){if(this!=&other){if(has_value_&&other.has_value_){// 两边都有值：优先直接赋值// 如果 T 不可拷贝赋值，退化为析构+构造ifconstexpr(std::is_copy_assignable_v<T>)value_=other.value_;else{value_.~T();new(&value_)T(other.value_);}}elseif(has_value_){// 只有 this 有值：析构变成空value_.~T();has_value_=false;}elseif(other.has_value_){// 只有 other 有值：placement newnew(&value_)T(other.value_);has_value_=true;}// 两边都无值：什么都不做}return*this;}// 移动赋值：逻辑同拷贝赋值Optional&operator=(Optional&&other){if(this!=&other){if(has_value_&&other.has_value_){// 两边都有值：优先直接移动赋值// 如果 T 不可移动赋值，退化为析构+构造ifconstexpr(std::is_move_assignable_v<T>)value_=std::move(other.value_);else{value_.~T();new(&value_)T(std::move(other.value_));}}elseif(has_value_){value_.~T();has_value_=false;}elseif(other.has_value_){new(&value_)T(std::move(other.value_));has_value_=true;}}return*this;}// nullopt 赋值：清空 optional// 允许写 opt = std::nullopt;Optional&operator=(std::nullopt_t){if(has_value_){value_.~T();has_value_=false;}return*this;}// ==================== 析构函数 ====================// 只有存在值时才需要析构~Optional(){if(has_value_)value_.~T();}// ==================== 值访问 ====================// 检查是否有值boolhas_value()const{returnhas_value_;}// 安全访问：无值时抛异常T&value(){if(!has_value_)throwstd::bad_optional_access();returnvalue_;}constT&value()const{if(!has_value_)throwstd::bad_optional_access();returnvalue_;}// 带默认值的访问：无值时返回 default_value// 返回值而非引用，因为可能返回临时对象// 必须是 const 成员函数Tvalue_or(constT&default_value)const{returnhas_value_?value_:default_value;}Tvalue_or(T&&default_value)const{returnhas_value_?value_:std::move(default_value);}// 不安全访问：调用者负责确保有值// 比 value() 更高效（无检查），但用错会 UBT&operator*(){returnvalue_;}constT&operator*()const{returnvalue_;}T*operator->(){return&value_;}constT*operator->()const{return&value_;}// 布尔转换：支持 if (opt) 语法// 必须是 const，否则无法用于 const Optionaloperatorbool()const{returnhas_value_;}// ==================== 比较运算符 ====================// 两个 Optional 比较：都有值时比较值，都无值时相等booloperator==(constOptional&other)const{if(has_value_&&other.has_value_)returnvalue_==other.value_;return!has_value_&&!other.has_value_;}booloperator!=(constOptional&other)const{return!operator==(other);}// 与值比较：有值且值相等时为 truebooloperator==(constT&value)const{returnhas_value_&&value_==value;}booloperator!=(constT&value)const{return!operator==(value);}// 与 nullopt 比较booloperator==(std::nullopt_t)const{return!has_value_;}booloperator!=(std::nullopt_t)const{returnhas_value_;}// ==================== 修改器 ====================// 清空：析构值并标记为空voidreset(){if(has_value_)value_.~T();has_value_=false;}// 原地构造：直接用参数构造 T，避免临时对象// 比 opt = T(args...) 更高效template<typename...Args>voidemplace(Args&&...args){if(has_value_)value_.~T();new(&value_)T(std::forward<Args>(args)...);has_value_=true;}private:// 匿名 union：禁用 value_ 的自动构造/析构// 让我们可以手动控制 T 的生命周期union{T value_;};boolhas_value_;};使用示例
// 基本用法Optional<std::string>name;if(!name){name.emplace("Alice");}std::cout<<name.value_or("Anonymous")<<std::endl;// 与 nulloptOptional<int>id=42;id=std::nullopt;// 清空// 安全 vs 不安全访问Optional<double>price=9.99;doublep1=price.value();// 安全，无值会抛异常doublep2=*price;// 快速，但调用者要确保有值// 比较Optional<int>a=10;Optional<int>b=10;Optional<int>c;a==b;// truea==10;// truec==std::nullopt;// true
