std::optional 如何从初始值设定项列表中构造 std::variant ？

Question

#include <optional>
#include <variant>
#include <utility>
#include <set>

int main()
{
    std::optional<std::variant<std::pair<int, int>, std::set<int>>> foo(std::in_place, {1, 4});
}

1. This compiles. But how is that possible when std::variant does not have a constructor that takes std::initializer_list<T> as its first argument , but all that this constructor overload of std::optional does is pass the initializer list and forward other arguments to the internal type constructor ?
2. Which type does the std::variant hold now, std::set or std::pair ?

Answer 1

It's a bit complicated, so bear with me.

optional<T> has a constructor that takes an in_place_t and an initializer_list<U> (and optional extra arguments). It will then attempt to construct T as if by this statement:

T t(list, ...);

Where list is the initailizer list and ... are any extra arguments.

T is of course a variant<pair, set> . variant is implicitly convertible from any type V through a template constructor. However, this constructor only exists if V is a type such that, given a value v of this type, the following is true:

W w(std::forward<V>(v));

Where W (I'm running out of letters here) is one of the types in the variant . Now variant can have multiple types, so variant basically considers all possible W s and their constructor overloads. So long as overload resolution selects exactly one such constructor among all possible W s in the variant , the conversion will work.

pair has no constructor that takes an initializer_list , so none of its constructors count. set<X> has a constructor that takes an initializer_list<X> .

So, back to the original statement. Because optional had an initializer_list<Y> parameter where Y is deduced, the braced-init-list will deduce Y as int . And int is the same type as the set in the variant . So set<int> can be constructed from an initailizer_list<int> .

And therefore, that's what gets created in the variant .

If you had a vector<int> as part of the variant , you'd get a compile error due to the ambiguity of which to call.

And there's not really a way to fix that through in_place gymnastics. You can't do (std::in_place, std::in_place_type<std::set>, {1, 4}) , because the braced-init-list won't get properly deduced. So you'd have to do (std::in_place, std::set{1, 4}) and let move construction move from the temporary into the variant .