std::variant<Types...>::variant

• This constructor is constexpr if and only if the value initialization of the alternative type T_0 would satisfy the requirements for a constexpr function.
• This overload participates in overload resolution only if std::is_default_constructible_v <T_0> is true.

• This constructor is defined as deleted unless std::is_copy_constructible_v <T_i> is true for all T_i in Types....
• It is trivial if std::is_trivially_copy_constructible_v <T_i> is true for all T_i in Types....

• This overload participates in overload resolution only if std::is_move_constructible_v <T_i> is true for all T_i in Types....
• It is trivial if std::is_trivially_move_constructible_v <T_i> is true for all T_i in Types....

Formally:

• An overload F(T_i) is only considered if the declaration T_i x[] = { std::forward <T>(t) }; is valid for some invented variable x.

• This overload participates in overload resolution only if
  • sizeof...(Types) > 0,
  • std::decay_t <T>(until C++20)std::remove_cvref_t <T>(since C++20) is neither the same type as variant, nor a specialization of std::in_place_type_t , nor a specialization of std::in_place_index_t ,
  • std::is_constructible_v <T_j, T> is true,
  • and the expression F(std::forward <T>(t)) (with F being the above-mentioned set of imaginary functions) is well formed.
• This constructor is a constexpr constructor if T_j's selected constructor is a constexpr constructor.

std::variant <std::string > v("abc"); // OK
std::variant <std::string, std::string > w("abc"); // ill-formed
std::variant <std::string, const char*> x("abc"); // OK, chooses const char*
std::variant <std::string, bool> y("abc"); // OK, chooses string; bool is not a candidate
std::variant <float, long, double> z = 0; // OK, holds long
 // float and double are not candidates

• If T's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor.
• This overload participates in overload resolution only if there is exactly one occurrence of T in Types... and std::is_constructible_v <T, Args...> is true.

• If T's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor.
• This overload participates in overload resolution only if there is exactly one occurrence of T in Types... and std::is_constructible_v <T, initializer_list<U>&, Args...> is true.

• If T_i's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor.
• This overload participates in overload resolution only if I < sizeof...(Types) and std::is_constructible_v <T_i, Args...> is true.

• If T_i's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor.
• This overload participates in overload resolution only if I < sizeof...(Types) and std::is_constructible_v <T_i, std::initializer_list <U>&, Args...> is true.

#include <cassert>
#include <iostream>
#include <string>
#include <variant>
#include <vector>
 
using vector_t = std::vector <int>;
 
auto& operator<<(auto& out, const vector_t& v)
{
 out << "{ ";
 for (int e : v)
 out << e << ' ';
 return out << '}';
}
 
int main()
{
 // value-initializes first alternative
 std::variant <int, std::string > var0;
 assert (std::holds_alternative <int>(var0) and
 var0.index() == 0 and
 std::get<int>(var0) == 0);
 
 // initializes first alternative with std::string{"STR"};
 std::variant <std::string, int> var1{"STR"};
 assert (var1.index() == 0);
 std::cout << "1) " << std::get<std::string >(var1) << '\n';
 
 // initializes second alternative with int == 42;
 std::variant <std::string, int> var2{42};
 assert (std::holds_alternative <int>(var2));
 std::cout << "2) " << std::get<int>(var2) << '\n';
 
 // initializes first alternative with std::string{4, 'A'};
 std::variant <std::string, vector_t, float> var3
 {
 std::in_place_type <std::string >, 4, 'A'
 };
 assert (var3.index() == 0);
 std::cout << "3) " << std::get<std::string >(var3) << '\n';
 
 // initializes second alternative with std::vector{1,2,3,4,5};
 std::variant <std::string, vector_t, char> var4
 {
 std::in_place_type <vector_t>, {1, 2, 3, 4, 5}
 };
 assert (var4.index() == 1);
 std::cout << "4) " << std::get<vector_t>(var4) << '\n';
 
 // initializes first alternative with std::string{"ABCDE", 3};
 std::variant <std::string, vector_t, bool> var5 {std::in_place_index <0>, "ABCDE", 3};
 assert (var5.index() == 0);
 std::cout << "5) " << std::get<std::string >(var5) << '\n';
 
 // initializes second alternative with std::vector(4, 42);
 std::variant <std::string, vector_t, char> var6 {std::in_place_index <1>, 4, 42};
 assert (std::holds_alternative <vector_t>(var6));
 std::cout << "6) " << std::get<vector_t>(var6) << '\n';
}

Output:

1) STR
2) 42
3) AAAA
4) { 1 2 3 4 5 }
5) ABC
6) { 42 42 42 42 }

• conditionally noexcept