如何以C++惯用法实现std::optional<T>到std::optional<U>的构造/转换？

你说得对，无法直接实现MyInt(opt_i)这种返回std::optional<MyInt>的语法——因为类的构造函数只能返回该类的实例，不能返回std::optional容器类型。下面是几种符合C++惯用法的最优解决方案：

方案1：类内静态工厂方法（封装性最优） #

在MyInt类中添加一个静态方法，专门处理std::optional<int>到std::optional<MyInt>的转换，逻辑清晰且符合封装原则：

#include <optional>

struct MyInt { 
  explicit MyInt(int i_) : i{i_} {}
  
  // 静态工厂方法：接受optional<int>，返回optional<MyInt>
  static std::optional<MyInt> from_optional(std::optional<int> opt) {
    if (opt.has_value()) {
      return MyInt(*opt);
    }
    return std::nullopt;
  }

  int i;
};

int main()
{
  MyInt i1 = MyInt(1);
  std::optional<int> opt_i{};
  std::optional<MyInt> i2 = MyInt::from_optional(opt_i);  // 空值
  opt_i = 3;
  std::optional<MyInt> i3 = MyInt::from_optional(opt_i);  // 包含MyInt(3)
}

方案2：使用C++20的std::optional::transform（简洁性最优） #

C++20为std::optional引入了transform成员函数，可以直接对内部值进行转换，空optional会直接传递为空，无需手动判断：

#include <optional>

struct MyInt { 
  explicit MyInt(int i_) : i{i_} {}
  int i;
};

int main()
{
  MyInt i1 = MyInt(1);
  std::optional<int> opt_i{};
  std::optional<MyInt> i2 = opt_i.transform([](int val) { return MyInt(val); });  // 空值
  opt_i = 3;
  std::optional<MyInt> i3 = opt_i.transform([](int val) { return MyInt(val); });  // 包含MyInt(3)
}

方案3：自由转换函数（灵活性最优） #

如果不想将转换逻辑绑定到类内部，可以定义一个全局或命名空间内的自由函数：

#include <optional>

struct MyInt { 
  explicit MyInt(int i_) : i{i_} {}
  int i;
};

// 自由转换函数
std::optional<MyInt> to_myint(std::optional<int> opt) {
  return opt ? std::optional<MyInt>(MyInt(*opt)) : std::nullopt;
}

int main()
{
  MyInt i1 = MyInt(1);
  std::optional<int> opt_i{};
  std::optional<MyInt> i2 = to_myint(opt_i);  // 空值
  opt_i = 3;
  std::optional<MyInt> i3 = to_myint(opt_i);  // 包含MyInt(3)
}

方案选择建议 #

• 若需要保持类的封装性，优先选择静态工厂方法；
• 若使用C++20及以上版本，transform成员函数是最简洁的标准库惯用法；
• 若转换逻辑需要在多个类间复用或独立于类，选择自由转换函数。

内容的提问来源于stack exchange，提问作者kc9jud