std::variant
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 variant at any given time either holds a value of one of its alternative types, or in the case of error - 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 T object is nested within the variant object.
A variant is not permitted to hold references, arrays, or the type void.
A variant is permitted to hold the same type more than once, and to hold differently cv-qualified versions of the same type.
Consistent with the behavior of unions during aggregate initialization, a default-constructed variant holds a value of its first alternative, unless that alternative is not default-constructible (in which case the variant is not default-constructible either). The helper class std::monostate can be used to make such variants default-constructible.
A program that instantiates the definition of std::variant with no template arguments is ill-formed. std::variant<std::monostate> can be used instead.
If a program declares an explicit or partial specialization of std::variant, the program is ill-formed, no diagnostic required.
Contents |
[edit]Template parameters
| Types | - | the types that may be stored in this variant. All types must meet the Destructible requirements (in particular, array types and non-object types are not allowed). |
[edit]Member functions
constructs the variant object (public member function) | |
destroys the variant, along with its contained value (public member function) | |
assigns a variant(public member function) | |
Observers | |
returns the zero-based index of the alternative held by the variant(public member function) | |
checks if the variant is in the invalid state (public member function) | |
Modifiers | |
constructs a value in the variant, in place (public member function) | |
swaps with another variant(public member function) | |
Visitation | |
(C++26) | calls the provided functor with the argument held by the variant(public member function) |
[edit]Non-member functions
(C++17) | calls the provided functor with the arguments held by one or more variants (function template) |
(C++17) | checks if a variant currently holds a given type (function template) |
(C++17) | reads the value of the variant given the index or the type (if the type is unique), throws on error (function template) |
(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) |
(C++17)(C++17)(C++17)(C++17)(C++17)(C++17)(C++20) | compares variant objects as their contained values (function template) |
(C++17) | specializes the std::swap algorithm (function template) |
[edit]Helper classes
(C++17) | placeholder type for use as the first alternative in a variant of non-default-constructible types (class) |
(C++17) | exception thrown on invalid accesses to the value of a variant(class) |
(C++17) | obtains the size of the variant's list of alternatives at compile time(class template)(variable template) |
| obtains the type of the alternative specified by its index, at compile time (class template)(alias template) | |
(C++17) | hash support for std::variant (class template specialization) |
[edit]Helper objects
(C++17) | index of the variant in the invalid state (constant) |
[edit]Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_variant | 201606L | (C++17) | std::variant: a type-safe union |
202102L | (C++23) (DR17) | std::visit for classes derived from std::variant | |
202106L | (C++23) (DR20) | Fully constexprstd::variant | |
202306L | (C++26) | Member visit |
[edit]Example
#include <cassert>#include <iostream>#include <string>#include <variant> int main(){ std::variant<int, float> v, w; v =42;// v contains intint i = std::get<int>(v);assert(42== i);// succeeds 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(conststd::bad_variant_access& ex){std::cout<< ex.what()<<'\n';} usingnamespace std::literals; std::variant<std::string> x("abc");// converting constructors work when unambiguous x ="def";// converting assignment also works when unambiguous std::variant<std::string, voidconst*> y("abc");// casts to void const* when passed a char const*assert(std::holds_alternative<voidconst*>(y));// succeeds y ="xyz"s;assert(std::holds_alternative<std::string>(y));// succeeds}
Possible output:
std::get: wrong index for variant
[edit]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 | specialization of std::uses_allocator provided, but variant cannot properly support allocators | specialization removed |
| LWG 3990 | C++17 | a program could declare an explicit or partial specialization of std::variant | the program is ill-formed in this case (no diagnostic required) |
| LWG 4141 | C++17 | the requirement for storage allocation was confusing | the contained object must be nested within the variant object |
[edit]See also
| in-place construction tag (tag) | |
(C++17) | a wrapper that may or may not hold an object (class template) |
(C++17) | objects that hold instances of any CopyConstructible type (class) |
