Difference between revisions of "cpp/utility/variant/get"

Revision as of 15:07, 29 October 2019

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

#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&) {}
}

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)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
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
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

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

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

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/utility/variant/get"

Revision as of 15:07, 29 October 2019

Contents

Template parameters

Parameters

Return value

Exceptions

Example

See also

Navigation

Toolbox

@@ Line 5: / Line 5: @@
 {{dcl rev begin | since=c++17 | num=1 }}
 {{dcl|
-template <std::size_t I, class... Types>
+template< std::size_t I, class... Types >
-constexpr std::variant_alternative_t<
+constexpr std::variant_alternative_t<I, std::variant<Types...>>&
-  I, std::variant<Types...>
+    get(std::variant<Types...>& v);
->& get(std::variant<Types...>& v); }}
+}}
 {{dcl|
-template <std::size_t I, class... Types>
+template< std::size_t I, class... Types >
-constexpr std::variant_alternative_t<
+constexpr std::variant_alternative_t<I, std::variant<Types...>>&&
-  I, std::variant<Types...>
+    get(std::variant<Types...>&& v);
->&& get(std::variant<Types...>&& v); }}
+}}
 {{dcl|
-template <std::size_t I, class... Types>
+template< std::size_t I, class... Types >
-constexpr std::variant_alternative_t<
+constexpr const std::variant_alternative_t<I, std::variant<Types...>>&
-  I, std::variant<Types...>
+    get(const std::variant<Types...>& v);
-> const& get(const std::variant<Types...>& v); }}
+}}
 {{dcl|
-template <std::size_t I, class... Types>
+template< std::size_t I, class... Types >
-constexpr std::variant_alternative_t<
+constexpr const std::variant_alternative_t<I, std::variant<Types...>>&
-  I, std::variant<Types...>
+    get( const std::variant<Types...>&& v );
-> const&& get(const std::variant<Types...>&& v);}}
+}}
 {{dcl rev end}}
 {{dcl rev begin | since=c++17 | num=2 }}
 {{dcl|
-template <class T, class... Types>
+template< class T, class... Types >
-constexpr T& get(std::variant<Types...>& v); }}
+constexpr T& get( std::variant<Types...>& v );
+}}
 {{dcl|
-template <class T, class... Types>
+template< class T, class... Types >
-constexpr T&& get(std::variant<Types...>&& v); }}
+constexpr T&& get( std::variant<Types...>&& v );
+}}
 {{dcl|
-template <class T, class... Types>
+template< class T, class... Types >
-constexpr const T& get(const std::variant<Types...>& v); }}
+constexpr const T& get( const std::variant<Types...>& v );
+}}
 {{dcl|
-template <class T, class... Types>
+template< class T, class... Types >
-constexpr const T&& get(const std::variant<Types...>&& v); }}
+constexpr const T&& get( const std::variant<Types...>&& v );
+}}
 {{dcl rev end}}
 {{dcl end}}