给定工厂对象和可变参数列表，是否可以就地初始化 std::variant ？

Answer 1

是的。

工厂需要包装在一个类型中，并转换为包含类型，并且包含类型需要不是有一个优先的构造函数。

template<typename F>
struct initializer {
  F init;
  operator auto() {
    return init();
  }
};
template<typename F>
initializer(F) -> initializer<F>;

struct to_construct {
  // must NOT exist
  // template<typename F>
  // to_construct(initializer<F>) { std::cout << "Foiled!\n"; }
  // or (more likely)
  // template<typename T>
  // to_construct(T) { std::cout << "Foiled again!\n"; }
  to_construct() = default;
  to_construct(to_construct&&) = delete;
  to_construct(to_construct const&) = delete;
};

int main() {
  std::variant<to_construct, int> v;
  v.emplace<to_construct>(initializer{[]() -> to_construct { std::cout << "Success\n"; return {}; }});
}

包含的类型不能有与initializer 匹配的构造函数这一点很重要：这意味着您不能安全地对您无法控制的类型的variants 执行此技巧。如果您需要以这种方式在variant 中构造一些外部T，请将T 包装在您自己控件的box 中，在这种情况下，您可以直接从工厂添加构造函数。

// do NOT do this, because it might fail silently and weirdly
// template<typename T>
// void foo() {
//   std::variant<int, T> v;
//   v.emplace<1>(initializer{[]() -> T { return {}; }});
// }

template<typename T>
struct box {
  T x;
  template<typename F>
  box(F f) : x(f()) { }
};
template<typename T>
void foo() {
  std::variant<int, box<T>> v;
  v.template emplace<1>([]() -> T { return {}; });
}

IE。您可以在工厂的 variant 中构造一个对象，而无需更改 variant 类型有时（当您控制替代品时），但通常您可能需要将一些替代品更改为boxs。

---

基于上述内容的扩展代码的问题是您尝试将initializer 与box 一起使用。 box 不需要initializer。它直接采用 lambdas。此外，由于初始化 lambda 不必超过 variant 的构造，它几乎不应该按值捕获。此外，如果您不想每次都手动指定您想要的替代方案，您应该让box 的构造函数在它不起作用时退出重载决议。

// it is convention in the C++ standard libraries to not bother forwarding functors
template<typename... Types, typename Factory, typename... Args>
std::variant<box<Types>...> variant_from(Factory f, Args&&... args) {
    return [&]() { return f(std::forward<Args>(args)...); };
}

template<typename T>
struct box {
  T x;
  template<
    typename F,
    typename = std::enable_if_t< // unsure if this is quite the right condition, it's a bit stricter than just "x(f()) would compile"
      std::is_same_v<
        T,
        std::decay_t<decltype(std::declval<F&>()())>>>>
  box(F f) : x(f()) { }
};