std::variant

 

C++

Language

Standard library headers

Concepts

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

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

optional, any and variant (C++17)

optional

any

variant

in_placein_place_tin_place_type_tin_place_index_t

Pairs and tuples

pair

tuple (C++11)

apply (C++17)

make_from_tuple (C++17)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

integer_sequence (C++14)

Swap, forward and move

swap

exchange (C++14)

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

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

uses_allocator

Helper objects

variant_npos

 

Defined in header <variant>
template <class... Types> class variant;		(since C++17)

The class template std::variant represents a type-safe union. An instance of std::variant at any given time either holds a value of one of its alternative types, or it holds no value (this state is hard to achieve, see valueless_by_exception).

As with unions, if a variant holds a value of some object type T, the object representation of T is allocated directly within the object representation of the variant itself. Variant is not allowed to allocate additional (dynamic) memory.

If a variant holds a value of a reference type, the implementation may choose to store it in the form of a wrapper type.

A variant is permitted to hold the type void, to hold the same type more than once, and to hold differently cv-qualified versions of the same type.

As with unions, the default-initialized variant holds a value of its first alternative, unless that alternative is not default-constructible (in which case default constructor won't compile: the helper class std::monostate can be used to make such variants default-constructible)

Template parameters

Types

-

the types that may be stored in this variant. All types must be (possibly cv-qualified) object types, (possibly cv-qualified) void, or reference types.

Member functions

(constructor)	constructs the variant object (public member function)
(destructor)	destroys the variant, along with its contained value (public member function)
operator=	assigns a variant (public member function)
Observers
index	returns the zero-based index of the alternative held by the variant (public member function)
valueless_by_exception	checks if the variant is in the invalid state (public member function)
Modifiers
emplace	constructs a value in the variant, in place (public member function)
swap	swaps with another variant (public member function)

Non-member functions

visit (C++17)	calls the provided functor with the arguments held by one or more variants (function template)
holds_alternative (C++17)	checks if a given type appears exactly once in a variant (function template)
std::get(std::variant) (C++17)	reads the value of the variant given the index or the type (if the type is unique), throws on error (function template)
get_if (C++17)	obtains a pointer to the value of a pointed-to variant given the index or the type (if unique), returns null on error (function template)
operator==operator!=operator<operator<=operator>operator>= (C++17)	compares variant objects as their contained values (function template)
std::swap(std::variant) (C++17)	specializes the std::swap algorithm (function)

Helper classes

monostate (C++17)	placeholder type for use as the first alternative in a variant of non-default-contructible types (class)
bad_variant_access (C++17)	exception thrown on invalid accesses to the value of a variant (class)
variant_sizevariant_size_v (C++17)	obtains the size of the variant's list of alternatives at compile time (class template) (variable template)
variant_alternativevariant_alternative_t (C++17)	obtains the type of the alternative specified by its index, at compile time (class template) (alias template)
std::hash<std::variant> (C++17)	specializes the std::hash algorithm (class template specialization)
std::uses_allocator<std::variant> (C++17)	specializes the std::uses_allocator type trait (class template specialization)

Helper objects

variant_npos (C++17)

index of the variant in the invalid state (constant)

Example

Run this code

#include <variant>
#include <string>
 
int main()
{
    std::variant<int, float> v, w;
    v = 12; // v contains int
    int i = std::get<int>(v);
    w = std::get<int>(v);
    w = std::get<0>(v); // same effect as the previous line
    w = v; // same effect as the previous line
 
//  std::get<double>(v); // error: no double in [int, float]
//  std::get<3>(v);      // error: valid index values are 0 and 1
 
    try {
      std::get<float>(w); // w contains int, not float: will throw
    }
    catch (std::bad_variant_access&) {}
 
    std::variant<std::string> v("abc"); // converting constructors work when unambiguous
    v = "def"; // converting assignment also works when unambiguous
}

See also

in_place in_place_t in_place_type_t in_place_index_t (since C++17)	in-place construction tag (function template)
optional (since C++17)	a wrapper that may or may not hold an object (class template)
any (since C++17)	Objects that hold instances of any CopyConstructible type. (class)