std::variant::variant

C++

Language

Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

Utilities library

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Library feature-test macros
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
integer_sequence (C++14)
Relational operators (deprecated)
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Comparisons (C++20)
strong_order weak_order partial_order strong_equal weak_equal	strong_ordering weak_ordering partial_ordering strong_equality weak_equality	is_eqis_neqis_ltis_lteqis_gtis_gteq
common_comparison_category
Common vocabulary types
pair tuple (C++11) apply (C++17) make_from_tuple (C++17)	optional (C++17) any (C++17) variant (C++17)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
Elementary string conversions
to_chars (C++17)
from_chars (C++17)
chars_format (C++17)
Type operations
declval (C++11)
as_const (C++17)

std::variant

Member functions

variant::variant

variant::~variant

variant::operator=

Observers

variant::index

variant::valueless_by_exception

Modifiers

variant::emplace

variant::swap

Non-member functions

visit

holds_alternative

get

get_if

operator==operator!=operator<operator<=operator>operator>=

swap

Helper classes

monostate

bad_variant_access

variant_size

variant_alternative

hash

Helper objects

variant_npos

constexpr variant() noexcept(/* see below */);	(1)	(since C++17)
variant(const variant& other);	(2)	(since C++17)
variant(variant&& other) noexcept(/* see below */);	(3)	(since C++17)
template< class T > constexpr variant(T&& t) noexcept(/* see below */);	(4)	(since C++17)
template< class T, class... Args > constexpr explicit variant(std::in_place_type_t<T>, Args&&... args);	(5)	(since C++17)
template< class T, class U, class... Args > constexpr explicit variant(std::in_place_type_t<T>, std::initializer_list<U> il, Args&&... args);	(6)	(since C++17)
template< std::size_t I, class... Args > constexpr explicit variant(std::in_place_index_t<I>, Args&&... args);	(7)	(since C++17)
template< std::size_t I, class U, class... Args > constexpr explicit variant(std::in_place_index_t<I>, std::initializer_list<U> il, Args&&... args);	(8)	(since C++17)

Constructs a new variant object.

1) Default constructor. Constructs a variant holding the value-initialized value of the first alternative (index() is zero). 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 only participates in overload resolution 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 contained value with std::get<other.index()>(other). Otherwise, initializes a valueless_by_exception variant. This constructor is defined as deleted unless std::is_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 contained value with std::get<other.index()>(std::move(other)). Otherwise, initializes a valueless_by_exception variant. This overload only participates in overload resolution if std::is_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 every T_i from Types... in scope at the same time. Direct-initializes the contained value as if by direct non-list-initialization from std::forward<T>(t). This overload only participates in overload resolution if sizeof...(Types) > 0, std::decay_t<U> (until C++20)std::remove_cvref_t<U> (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.

variant<string> v("abc"); // OK
variant<string, string> w("abc"); // ill-formed, can't select the alternative to convert to
variant<string, bool> x("abc"); // OK, but chooses bool

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 constructor is also a constexpr constructor. This overload only participates in overload resolution 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 constructor is also a constexpr constructor. This overload only participates in overload resolution if there is exactly one occurrence of T in Types... and std::is_constructible_v<T, initializer_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::forward<Args>(args).... If T_i's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor. This overload only participates in overload resolution 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::forward<Args>(args).... If T_i's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor. This overload only participates in overload resolution 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

Defect reports

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

DR	Applied to	Behavior as published	Correct behavior
LWG 2901	C++17	allocator-aware constructors provided but variant can't properly support allocators	constructors removed
P0739R0	C++17	converting constructor template interacts poorly with class template argument deduction	constraint added
LWG 3024	C++17	copy constructor doesn't participate in overload resolution if any member type is not copyable	defined as deleted instead