Difference between revisions of "cpp/utility/variant/get"
From cppreference.com
m (→Example: prints ex.what()) |
m (→Example: w = 42) |
||
| Line 84: | Line 84: | ||
try | try | ||
{ | { | ||
| + | w = 42.0f; | ||
| + | std::cout << std::get<float>(w) << '\n'; // ok, prints 42 | ||
w = 42; | w = 42; | ||
| − | std::cout << std::get<float>(w) << '\n'; | + | std::cout << std::get<float>(w) << '\n'; // throws |
} | } | ||
catch (std::bad_variant_access const& ex) | catch (std::bad_variant_access const& ex) | ||
| Line 95: | Line 97: | ||
| output= | | output= | ||
12 | 12 | ||
| + | 42 | ||
Unexpected index: w contained int, not float | Unexpected index: w contained int, not float | ||
}} | }} | ||
Revision as of 00:48, 6 November 2020
| Defined in header <variant>
|
||
| (1) | (since C++17) | |
| template< std::size_t I, class... Types > constexpr std::variant_alternative_t<I, std::variant<Types...>>& |
||
| template< std::size_t I, class... Types > constexpr std::variant_alternative_t<I, std::variant<Types...>>&& |
||
| template< std::size_t I, class... Types > constexpr const std::variant_alternative_t<I, std::variant<Types...>>& |
||
| template< std::size_t I, class... Types > constexpr const std::variant_alternative_t<I, std::variant<Types...>>&& |
||
| (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....Contents |
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 <variant> #include <string> #include <iostream> 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
See 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) |
