std::variant - cppreference.com (original) (raw)

| | | | | ------------------------------------------ | | ------------- | | 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

• 1 Template parameters
• 2 Member functions
  • 2.1 Observers
  • 2.2 Modifiers
  • 2.3 Visitation
• 3 Non-member functions
• 4 Helper classes
• 5 Helper objects
• 6 Notes
• 7 Example
• 8 Defect reports
• 9 See also

[edit] Template parameters

[edit] Member functions

[edit] Non-member functions

[edit] Helper classes

[edit] Helper objects

[edit] Notes

[edit] Example

#include #include #include #include   int main() { std::variant<int, float> v, w; v = 42; // v contains int int i = std::get(v); assert(42 == i); // succeeds w = std::get(v); w = std::get<0>(v); // same effect as the previous line w = v; // same effect as the previous line   // std::get(v); // error: no double in [int, float] // std::get<3>(v); // error: valid index values are 0 and 1   try { std::get(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 }

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.

[edit] See also