std::get(std::pair)

From cppreference.com
< cpp‎ | utility‎ | pair
 
 
Utilities library
General utilities
Date and time
Function objects
Formatting library (C++20)
(C++11)
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)   
(C++20)
Swap and type operations
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
Elementary string conversions
(C++17)
(C++17)
 
std::pair
Member functions
(C++11)
Non-member functions
(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
(C++11)
get
(C++11)
Deduction guides(C++17)
Helper classes
(C++11)
 
Defined in header <utility>
(1)
template< std::size_t I, class T1, class T2 >

typename std::tuple_element<I, std::pair<T1,T2> >::type&

    get( std::pair<T1, T2>& p ) noexcept;
(since C++11)
(until C++14)
template< std::size_t I, class T1, class T2 >

constexpr std::tuple_element_t<I, std::pair<T1,T2> >&

    get( std::pair<T1, T2>& p ) noexcept;
(since C++14)
(2)
template< std::size_t I, class T1, class T2 >

const typename std::tuple_element<I, std::pair<T1,T2> >::type&

    get( const std::pair<T1,T2>& p ) noexcept;
(since C++11)
(until C++14)
template< std::size_t I, class T1, class T2 >

constexpr const std::tuple_element_t<I, std::pair<T1,T2> >&

    get( const std::pair<T1,T2>& p ) noexcept;
(since C++14)
(3)
template< std::size_t I, class T1, class T2 >

typename std::tuple_element<I, std::pair<T1,T2> >::type&&

    get( std::pair<T1,T2>&& p ) noexcept;
(since C++11)
(until C++14)
template< std::size_t I, class T1, class T2 >

constexpr std::tuple_element_t<I, std::pair<T1,T2> >&&

    get( std::pair<T1,T2>&& p ) noexcept;
(since C++14)
(4)
template< std::size_t I, class T1, class T2 >

const typename std::tuple_element<I, std::pair<T1,T2> >::type&&

    get( const std::pair<T1,T2>&& p ) noexcept;
(since C++11)
(until C++14)
template< std::size_t I, class T1, class T2 >

constexpr const std::tuple_element_t<I, std::pair<T1,T2> >&&

    get( const std::pair<T1,T2>&& p ) noexcept;
(since C++14)
template <class T, class U>
constexpr T& get(std::pair<T, U>& p) noexcept;
(5) (since C++14)
template <class T, class U>
constexpr const T& get(const std::pair<T, U>& p) noexcept;
(6) (since C++14)
template <class T, class U>
constexpr T&& get(std::pair<T, U>&& p) noexcept;
(7) (since C++14)
template <class T, class U>
constexpr const T&& get(const std::pair<T, U>&& p) noexcept;
(8) (since C++14)
template <class T, class U>
constexpr T& get(std::pair<U, T>& p) noexcept;
(9) (since C++14)
template <class T, class U>
constexpr const T& get(const std::pair<U, T>& p) noexcept;
(10) (since C++14)
template <class T, class U>
constexpr T&& get(std::pair<U, T>&& p) noexcept;
(11) (since C++14)
template <class T, class U>
constexpr const T&& get(const std::pair<U, T>&& p) noexcept;
(12) (since C++14)

Extracts an element from the pair using tuple-like interface.

The index-based overloads (1-4) fail to compile if the index I is neither 0 nor 1.

The type-based overloads (5-12) fail to compile if the types T and U are the same.

Parameters

p - pair whose contents to extract

Return value

1-4) Returns a reference to p.first if I==0 and a reference to p.second if I==1.
5-8) Returns a reference to p.first.
9-12) Returns a reference to p.second.

Example

#include <iostream>
#include <utility>
 
int main()
{
    auto p = std::make_pair(1, 3.14);
    std::cout << '(' << std::get<0>(p) << ", " << std::get<1>(p) << ")\n";
    std::cout << '(' << std::get<int>(p) << ", " << std::get<double>(p) << ")\n";
}

Output:

(1, 3.14)
(1, 3.14)

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 2485 C++11 (by index)
C++14 (by type)
there are no overloads for const pair&& the overloads are added

See also

Structured binding (C++17) binds the specified names to sub-objects or tuple elements of the initializer
tuple accesses specified element
(function template)
accesses an element of an array
(function template)
reads the value of the variant given the index or the type (if the type is unique), throws on error
(function template)
obtains iterator or sentinel from a std::ranges::subrange
(function template)