std::get (std::variant)

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Library feature-test macros
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
integer_sequence (C++14)
Relational operators (deprecated in C++20)
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Comparisons (C++20)
strong_order weak_order partial_order strong_equal weak_equal	strong_ordering weak_ordering partial_ordering strong_equality weak_equality	is_eqis_neqis_ltis_lteqis_gtis_gteq
common_comparison_category
Common vocabulary types
pair tuple (C++11) apply (C++17) make_from_tuple (C++17)	optional (C++17) any (C++17) variant (C++17)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
Elementary string conversions
to_chars (C++17)
from_chars (C++17)
chars_format (C++17)
Type operations
declval (C++11)
as_const (C++17)
launder (C++17)

 

std::variant

Member functions

variant::variant

variant::~variant

variant::operator=

Observers

variant::index

variant::valueless_by_exception

Modifiers

variant::emplace

variant::swap

Non-member functions

visit

holds_alternative

get

get_if

operator==operator!=operator<operator<=operator>operator>=

swap

Helper classes

monostate

bad_variant_access

variant_size

variant_alternative

hash

Helper objects

variant_npos

 

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 std::variant_alternative_t<   I, std::variant<Types...> > const& get(const std::variant<Types...>& v);
template <std::size_t I, class... Types> constexpr std::variant_alternative_t<   I, std::variant<Types...> > const&& 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 is not a valid index in the variant.

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

Parameters

I	-	index to look up
Type	-	unique type to look up
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 <variant>
#include <string>
 
int main()
{
    std::variant<int, float> v{12}, w;
    int i = std::get<int>(v);
    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 {
      std::get<float>(w); // w contains int, not float: will throw
    }
    catch (std::bad_variant_access&) {}
}

See also

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)
std::get(std::tuple)	tuple accesses specified element (function template)
std::get(std::array)	accesses an element of an array (function template)
std::get(std::pair) (C++11)	accesses an element of a pair (function template)