# std::variant

> C++ Atlas: `cppatlas.com/w/cpp/utility/variant` | Source: https://en.cppreference.com/w/cpp/utility/variant | Domain: Utility | Standards: C++17, C++20, C++26

The class template std::variant represents a type-safe union.

## Official Specification Summary (cppreference)

```cpp
// 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 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 itself. Variant is not allowed to allocate additional (dynamic) memory.

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

- `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).

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

**Visitation**

- `visit` (C++26): calls the provided functor with the argument held by the `variant` (public member function)

### Non-member functions

- `visit` (C++17): calls the provided functor with the arguments held by one or more `variant`s (function template)
- `holds_alternative` (C++17): checks if a `variant` currently holds a given type (function template)
- `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==` (C++17), `operator!=` (C++17), `operator<` (C++17), `operator<=` (C++17), `operator>` (C++17), `operator>=` (C++17), `operator<=>` (C++20): compares `variant` objects as their contained values (function template)
- `std::swap(std::variant)` (C++17): specializes the `std::swap` algorithm (function template)

### Helper classes

- `monostate` (C++17): placeholder type for use as the first alternative in a `variant` of non-default-constructible types (class)
- `bad_variant_access` (C++17): exception thrown on invalid accesses to the value of a `variant` (class)
- `variant_size` (C++17), `variant_size_v`: obtains the size of the `variant`'s list of alternatives at compile time (class template) (variable template)
- `variant_alternative` (C++17), `variant_alternative_t`: obtains the type of the alternative specified by its index, at compile time (class template) (alias template)
- `std::hash<std::variant>` (C++17): hash support for `std::variant` (class template specialization)

### Helper objects

- `variant_npos` (C++17): index of the `variant` in the invalid state (constant)

### Notes

| Feature-test macro | Value | Std | Feature |
| --- | --- | --- | --- |
| `__cpp_lib_variant` | `201606L` | (C++17) | `std::variant`: a type-safe union |
| `__cpp_lib_variant` | `202102L` | (C++23) (DR17) | `std::visit` for classes derived from `std::variant` |
| `__cpp_lib_variant` | `202106L` | (C++23) (DR20) | Fully `constexpr` `std::variant` |
| `__cpp_lib_variant` | `202306L` | (C++26) | Member `visit` |

### Example

```cpp
#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
}
```

Possible output:

```text
std::get: wrong index for variant
```

### 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 `std::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) |

### See also

- [`in_place`](https://en.cppreference.com/w/cpp/utility/in_place) (C++17), [`in_place_type`](https://en.cppreference.com/w/cpp/utility/in_place), [`in_place_index`](https://en.cppreference.com/w/cpp/utility/in_place), [`in_place_t`](https://en.cppreference.com/w/cpp/utility/in_place), [`in_place_type_t`](https://en.cppreference.com/w/cpp/utility/in_place), [`in_place_index_t`](https://en.cppreference.com/w/cpp/utility/in_place): in-place construction tag (tag)
- [`optional`](https://en.cppreference.com/w/cpp/utility/optional) (C++17): a wrapper that may or may not hold an object (class template)
- [`any`](https://en.cppreference.com/w/cpp/utility/any) (C++17): objects that hold instances of any *CopyConstructible* type (class)

---
Attribution: content from https://en.cppreference.com/w/cpp/utility/variant (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.