如何实现接受std::optional参数的通透式构造函数生成std::optional<U>？

需求场景 #

希望在C++中实现一种惯用方式，让构造逻辑可以接受一个或多个std::optional<T>类型参数（允许与普通参数混合），最终返回std::optional<U>。例如针对Rational类，需要满足：

• 当传入的std::optional参数为空时，返回空的std::optional<Rational>
• 当所有std::optional参数都有值时，用解包后的参数构造Rational并包装为std::optional<Rational>返回

用户给出的理想使用示例如下：

#include <optional>

struct Rational { 
  explicit Rational(int i) : num{i}, denom{1} {}
  Rational(int i, int j) : num{i}, denom{j} {}
  int num, denom;
};

int main()
{
  Rational i1 = Rational(1);    // 表示数值1
  Rational h2 = Rational(1,2);  // 表示数值1/2
  std::optional<int> opt_i{}, opt_j{};

  std::optional<Rational> e3 = std::optional<Rational>(opt_i);
      // 期望生成空对象

  /* std::optional<Rational> e4 = std::optional<Rational>(opt_i, 2); */
  /* std::optional<Rational> e5 = std::optional<Rational>(2, opt_i); */
  /* std::optional<Rational> e6 = std::optional<Rational>(opt_i, opt_j); */
      // 期望返回空的std::optional<Rational>

  opt_i = 3;
  std::optional<Rational> i7 = std::optional<Rational>(opt_i);
      // 期望包含Rational(3)

  /* std::optional<Rational> r8 = std::optional<Rational>(opt_i, 2); */
  /* std::optional<Rational> r9 = std::optional<Rational>(2, opt_i); */
      // 期望分别生成包含3/2和2/3的std::optional<Rational>

  opt_j = 4;
  /* std::optional<Rational> r10 = std::optional<Rational>(opt_i, opt_j); */
      // 期望生成包含3/4的std::optional<Rational>
}

由于std::optional仅针对简单转换/拷贝构造提供了重载，无法直接支持上述多参数混合场景，以下是两种最佳实现方案：

方案一：通用工厂函数（推荐） #

实现一个模板工厂函数make_optional_from，自动处理参数解包与空值检查，适用于任意类的构造场景：

#include <optional>
#include <tuple>
#include <type_traits>

template <typename T, typename... Args>
std::optional<T> make_optional_from(Args&&... args) {
    // 解包单个参数：如果是std::optional则检查空值，否则直接返回原参数
    auto unwrap_arg = [](auto&& arg) -> decltype(auto) {
        if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::optional<std::decay_t<decltype(*arg)>>>) {
            if (!arg) {
                return std::optional<std::decay_t<decltype(*arg)>>{};
            }
            return *arg;
        } else {
            return std::forward<decltype(arg)>(arg);
        }
    };

    // 收集解包后的参数到tuple中
    auto args_tuple = std::make_tuple(unwrap_arg(std::forward<Args>(args))...);

    // 检查tuple中是否存在空的std::optional参数
    auto has_empty_opt = [](const auto& tuple) {
        return std::apply([](const auto&... elems) {
            return (... || (std::is_same_v<std::decay_t<decltype(elems)>, std::optional<std::decay_t<decltype(elems)>>> && !elems));
        }, tuple);
    };

    // 存在空参数则返回空的std::optional
    if (has_empty_opt(args_tuple)) {
        return std::nullopt;
    }

    // 所有参数有效，原地构造T并返回
    return std::apply([](auto&&... unwrapped) {
        return std::optional<T>(std::in_place, std::forward<decltype(unwrapped)>(unwrapped)...);
    }, args_tuple);
}

struct Rational { 
    explicit Rational(int i) : num{i}, denom{1} {}
    Rational(int i, int j) : num{i}, denom{j} {}
    int num, denom;
};

int main()
{
    Rational i1 = Rational(1);
    Rational h2 = Rational(1,2);
    std::optional<int> opt_i{}, opt_j{};

    std::optional<Rational> e3 = make_optional_from<Rational>(opt_i);
    std::optional<Rational> e4 = make_optional_from<Rational>(opt_i, 2);
    std::optional<Rational> e5 = make_optional_from<Rational>(2, opt_i);
    std::optional<Rational> e6 = make_optional_from<Rational>(opt_i, opt_j);

    opt_i = 3;
    std::optional<Rational> i7 = make_optional_from<Rational>(opt_i);
    std::optional<Rational> r8 = make_optional_from<Rational>(opt_i, 2);
    std::optional<Rational> r9 = make_optional_from<Rational>(2, opt_i);

    opt_j = 4;
    std::optional<Rational> r10 = make_optional_from<Rational>(opt_i, opt_j);
}

方案优势 #

• 通用性强：无需修改目标类的代码，适用于任意拥有构造函数的类
• 扩展性好：自动适配任意数量、任意混合类型的参数组合
• 逻辑统一：所有空值检查和参数解包逻辑集中处理

方案二：类内静态工厂方法 #

如果仅针对特定类（如Rational）实现，可以在类内部添加静态成员函数，逐一处理不同的参数组合：

#include <optional>

struct Rational { 
    explicit Rational(int i) : num{i}, denom{1} {}
    Rational(int i, int j) : num{i}, denom{j} {}

    // 处理单个std::optional<int>参数
    static std::optional<Rational> create(std::optional<int> i) {
        return i ? std::optional<Rational>(*i) : std::nullopt;
    }

    // 处理std::optional<int> + int参数
    static std::optional<Rational> create(std::optional<int> i, int j) {
        return i ? std::optional<Rational>(*i, j) : std::nullopt;
    }

    // 处理int + std::optional<int>参数
    static std::optional<Rational> create(int i, std::optional<int> j) {
        return j ? std::optional<Rational>(i, *j) : std::nullopt;
    }

    // 处理两个std::optional<int>参数
    static std::optional<Rational> create(std::optional<int> i, std::optional<int> j) {
        return (i && j) ? std::optional<Rational>(*i, *j) : std::nullopt;
    }

    int num, denom;
};

int main()
{
    Rational i1 = Rational(1);
    Rational h2 = Rational(1,2);
    std::optional<int> opt_i{}, opt_j{};

    std::optional<Rational> e3 = Rational::create(opt_i);
    std::optional<Rational> e4 = Rational::create(opt_i, 2);
    std::optional<Rational> e5 = Rational::create(2, opt_i);
    std::optional<Rational> e6 = Rational::create(opt_i, opt_j);

    opt_i = 3;
    std::optional<Rational> i7 = Rational::create(opt_i);
    std::optional<Rational> r8 = Rational::create(opt_i, 2);
    std::optional<Rational> r9 = Rational::create(2, opt_i);

    opt_j = 4;
    std::optional<Rational> r10 = Rational::create(opt_i, opt_j);
}

方案优势 #

• 逻辑直观：每个静态方法对应明确的参数组合，便于调试和维护
• 性能略优：避免了通用模板的编译期开销，针对特定场景做了精简

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