std::variant

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.

Template parameters

Member functions

Non-member functions

Helper classes

Helper objects

Notes

Example

#include <cassert>
#include <iostream>
#include <string>
#include <variant>
 
int main()
{
 std::variant<int, float> v, w;
 v = 42; // v contains int
 int 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 (const std::bad_variant_access & ex)
 {
 std::cout << ex.what() << '\n';
 }
 
 using namespace 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, void const*> y("abc");
 // casts to void const* when passed a char const*
 assert (std::holds_alternative <void const*>(y)); // succeeds
 y = "xyz"s;
 assert (std::holds_alternative <std::string >(y)); // succeeds
}

std::get: wrong index for variant

Defect reports

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

See also

• In other languages

• Español
• 日本語
• Русский
• 中文