home | help
std::variant::variant(3)       C++ Standard Libary	std::variant::variant(3)

NAME
     std::variant::variant - std::variant::variant

Synopsis
	constexpr  variant()  noexcept(/*  see	below  */);		     (1)
     (since C++17)
	constexpr variant(  const  variant&  other  );			     (2)
     (since C++17)
	constexpr  variant(  variant&&	other  )  noexcept(/* see below */); (3)
     (since C++17)
	template<  class  T  >						     (4)
     (since C++17)
	constexpr variant( T&& t ) noexcept(/* see below */);
	template< class T,

		  class...   Args   >					     (5)
     (since C++17)
	constexpr explicit variant( std::in_place_type_t<T>,

				    Args&&... args );
	template< class T,

		  class U,
		  class...  Args   >					     (6)
     (since C++17)
	constexpr explicit variant( std::in_place_type_t<T>,
				    std::initializer_list<U> il,

				    Args&&... args );
	template< std::size_t I,

		  class...   Args   >					     (7)
     (since C++17)
	constexpr explicit variant( std::in_place_index_t<I>,

				    Args&&... args );
	template< std::size_t I,

		  class U,
		  class...  Args   >					     (8)
     (since C++17)
	constexpr explicit variant( std::in_place_index_t<I>,
				    std::initializer_list<U> il,

				    Args&&... args );

	Constructs a new variant object.

	1)  Default constructor. Constructs a variant holding the value-initial-
     ized value of
	the first alternative (index() is zero).
	  * This constructor is constexpr if and only if the  value  initializa-
     tion 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.
	2) Copy constructor. If other is not valueless_by_exception,  constructs
     a variant
	holding  the  same  alternative as other and direct-initializes the con-
     tained value
	with *std::get_if<other.index()>(std::addressof(other)). Otherwise, ini-
     tializes a
	valueless_by_exception variant.
	  * This constructor is  defined  as  deleted  unless  std::is_copy_con-
     structible_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....
	3)  Move constructor. If other is not valueless_by_exception, constructs
     a variant
	holding the same alternative as other and  direct-initializes  the  con-
     tained value
	with std::move(*std::get_if<other.index()>(std::addressof(other))). Oth-
     erwise,
	initializes a valueless_by_exception variant.
	  * 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....
	4)  Converting constructor. Constructs a variant holding the alternative
     type T_j
	that would be selected by overload resolution for the expression
	F(std::forward<T>(t)) if there was an  overload  of  imaginary	function
     F(T_i) for each
	T_i in Types..., except that narrowing conversions aren't considered.

	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.
	Direct-initializes the contained value as if by direct non-list-initial-
     ization from
	std::forward<T>(t).
	  * 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 spe-
     cialization of
		 std::in_place_type_t, nor a specialization of std::in_place_in-
     dex_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 con-
     structor 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  can-
     didates

	5) Constructs a variant with the specified alternative T and initializes
     the
	contained value with the arguments std::forward<Args>(args)....
	  *  If  T's  selected constructor is a constexpr constructor, this con-
     structor 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.
	6) Constructs a variant with the specified alternative T and initializes
     the
	contained value with the arguments il, std::forward<Args>(args)....
	  * If T's selected constructor is a constexpr	constructor,  this  con-
     structor 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,	initial-
     izer_list<U>&,
	    Args...> is true.
	7)  Constructs a variant with the alternative T_i specified by the index
     I and
	initializes  the  contained   value   with   the   arguments   std::for-
     ward<Args>(args)....
	  *  If T_i's selected constructor is a constexpr constructor, this con-
     structor 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.
	8)  Constructs a variant with the alternative T_i specified by the index
     I and
	initializes  the  contained  value  with  the  arguments  il,  std::for-
     ward<Args>(args)....
	  *  If T_i's selected constructor is a constexpr constructor, this con-
     structor 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.

Parameters
	other	- another variant object whose contained value to copy/move
	t	- value to initialize the contained value with
	args... - arguments to initialize the contained value with
	il	- initializer list to initialize the contained value with

Exceptions
	1)  May  throw	any  exception thrown by the value initialization of the
     first
	alternative.
	noexcept specification:
	noexcept(std::is_nothrow_default_constructible_v<T_0>)
	2) May throw any exception thrown  by  direct-initializing  any  T_i  in
     Types....
	3)  May  throw	any  exception	thrown	by  move-constructing any T_i in
     Types....
	noexcept specification:
	noexcept((std::is_nothrow_move_constructible_v<Types> && ...))
	4) May throw any exception thrown by the initialization of the	selected
     alternative
	T_j.
	noexcept specification:
	noexcept(std::is_nothrow_constructible_v<T_j, T>)
	5-8)  May throw any exception thrown by calling the selected constructor
     of the
	selected alternative.

Example
     // Run this code

      #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_in-
     dex<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_in-
     dex<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 }

	Defect reports

	The following behavior-changing defect	reports  were  applied	retroac-
     tively to
	previously published C++ standards.

	   DR	  Applied  to	      Behavior as published		 Correct
     behavior
			    allocator-aware constructors
	LWG 2901 C++17	     provided  but			    constructors
     removed
			    variant can't properly support
			    allocators
			    converting constructor template
	P0739R0    C++17	interacts			      constraint
     added
			    poorly with class template argument
			    deduction
			    copy constructor doesn't participate
	LWG  3024  C++17       in				     defined  as
     deleted instead
			    overload resolution if any member
			    type is not copyable
			    copy/move  constructors  may  not  be    required to
     propagate
	P0602R4  C++17	    trivial even if underlying		 triviality
			    constructors are trivial
			    converting constructor blindly
	P0608R3  C++17	    assembles				  narrowing  and
     boolean
			    an overload set, leading to 	 conversions not
     considered
			    unintended conversions
								 Pointer to bool
     conversion
			    converting	constructor  for  bool did  is narrowing
     and
	P1957R2  C++17	    not allow				 converting con-
     structor has
			    implicit conversion 		 no
								 exception   for
     bool

Category:
	  * conditionally noexcept

http://cppreference.com 	   2024.06.10		std::variant::variant(3)

home | help