| 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 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....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
#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";
}
}12
42
Unexpected index: w contained int, not floatSee also
| (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) |
| (C++11) |
tuple accesses specified element (function template) |
| (C++11) |
accesses an element of an array (function template) |
| (C++11) |
accesses an element of a pair (function template) |
| (C++20) |
obtains iterator or sentinel from a std::ranges::subrange (function template) |
| (C++26) |
obtains a reference to real or imaginary part from a std::complex (function template) |
Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.