std::get(std::variant)

Defined in header `<variant>`
	(1)	(since C++17)
template < std::size_t I, class... Types > constexpr std::variant_alternative_t <I, std::variant <Types...>> & get( std::variant <Types...> & v ) ;
template < std::size_t I, class... Types > constexpr std::variant_alternative_t <I, std::variant <Types...>> && get( std::variant <Types...> && v ) ;
template < std::size_t I, class... Types > constexpr const std::variant_alternative_t <I, std::variant <Types...>> & get( const std::variant <Types...> & v ) ;
template < std::size_t I, class... Types > constexpr const std::variant_alternative_t <I, std::variant <Types...>> && get( const std::variant <Types...> && v ) ;
			(2)	(since C++17)
template < class T, class... Types > constexpr T& get( std::variant <Types...> & v ) ;
template < class T, class... Types > constexpr T&& get( std::variant <Types...> && v ) ;
template < class T, class... Types > constexpr const T& get( const std::variant <Types...> & v ) ;
template < class T, class... Types > constexpr const T&& get( const std::variant <Types...> && v ) ;

1) Index-based value accessor: If v.index() == I, returns a reference to the value stored in v. Otherwise, throws std::bad_variant_access. The call is ill-formed if I

2) Type-based value accessor: If v holds the alternative T, returns a reference to the value stored in v. Otherwise, throws std::bad_variant_access. The call is ill-formed if T is not a unique element of Types...

Template parameters

I	-	index to look up
T	-	unique type to look up
Types...	-	types forming the `variant`

Parameters

v - a variant

Return value

Reference to the value stored in the variant.

Exceptions

1,2) Throws std::bad_variant_access on errors.

Example

Run this code

#include <iostream>
#include <string>
#include <variant>
 
int main()
{
    std::variant<int, float> v{12}, w;
    std::cout << std::get<int>(v) << '\n';
    w = std::get<int>(v);
    w = std::get<0>(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
    {
        w = 42.0f;
        std::cout << std::get<float>(w) << '\n'; // ok, prints 42
        w = 42;
        std::cout << std::get<float>(w) << '\n'; // throws
    }
    catch (std::bad_variant_access const& ex)
    {
        std::cout << ex.what() << ": w contained int, not float\n";
    }
}

Possible output:

12
42
Unexpected index: w contained int, not float

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Member functions
variant::variant
variant::~variant
variant::operator=
Observers
variant::index
variant::valueless_by_exception
Modifiers
variant::emplace
variant::swap
Visitation
variant::visit (C++26)
Non-member functions
visit(std::variant)
holds_alternative
get(std::variant)
get_if
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)
swap(std::variant)
Helper classes
monostate
bad_variant_access
variant_size
variant_alternative
hash<std::variant>
Helper objects
variant_npos

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)
get(std::tuple) (C++11)	tuple accesses specified element (function template)
get(std::array) (C++11)	accesses an element of an `array` (function template)
get(std::pair) (C++11)	accesses an element of a `pair` (function template)
get(std::ranges::subrange) (C++20)	obtains iterator or sentinel from a std::ranges::subrange (function template)
get(std::complex) (C++26)	obtains a reference to real or imaginary part from a std::complex (function template)