SysTutorials

Linux Manual Pages › Section 3

stdgetstdpair(3)

std::get(std::pair) - std::get(std::pair)

Synopsis

Defined in header<utility>
    template <size_t I, class T1, class T2>
    (since C++ 11)
        typename std::tuple_element<I, std::pair<T1, T2>>::type &(1)(until C++ 14)
            get(pair<T1, T2> &p) noexcept;
template <size_t I, class T1, class T2>
constexpr std::tuple_element_t<I, std::pair<T1, T2>> &(1)(since C++ 14)
    get(pair<T1, T2> &p) noexcept;
template <size_t I, class T1, class T2>
(since C++ 11)
    const typename std::tuple_element<I, std::pair<T1, T2>>::type &(2)(until C++ 14)
        get(const pair<T1, T2> &p) noexcept;
template <size_t I, class T1, class T2>
constexpr const std::tuple_element_t<I, std::pair<T1, T2>> &(2)(since C++ 14)
    get(const pair<T1, T2> &p) noexcept;
template <size_t I, class T1, class T2>
    (since C++ 11)
        typename std::tuple_element<I, std::pair<T1, T2>>::type
    && (3)(until C++ 14)
           get(std::pair<T1, T2> &&p) noexcept;
template <size_t I, class T1, class T2>
    constexpr std::tuple_element_t<I, std::pair<T1, T2>> && (3)(since C++ 14)
                                                                get(std::pair<T1, T2> &&p) noexcept;
template <size_t I, class T1, class T2>
    (1)
        constexpr const std::tuple_element_t<I, std::pair<T1, T2>> &&
    (4)(since C++ 17)
        get(const std::pair<T1, T2> &&p) noexcept;
template <class T, class U>
(2)(5)(since C++ 14)
    constexpr T &get(std::pair<T, U> &p) noexcept;
template <class T, class U>
(6)(since C++ 14)
    constexpr const T &get(const std::pair<T, U> &p) noexcept;
(3)
    template <class T, class U>
    (7)(since C++ 14)
        constexpr T &&get(std::pair<T, U> &&p) noexcept;
template <class T, class U>
(8)(since C++ 17)
    constexpr const T &&get(const std::pair<T, U> &&p) noexcept;
template <class T, class U>
(9)(since C++ 14)
    constexpr T &get(std::pair<U, T> &p) noexcept;
template <class T, class U>
(10)(since C++ 14)
    constexpr const T &get(const std::pair<U, T> &p) noexcept;
template <class T, class U>
(11)(since C++ 14)
    constexpr T &&get(std::pair<U, T> &&p) noexcept;
template <class T, class U>
(12)(since C++ 17)
    constexpr const T &&get(const std::pair<U, T> &&p) noexcept;

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

// Run this code

#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)

See also

                       tuple accesses specified element std::get(std::tuple) (function template)                        accesses an element of an array std::get(std::array) (function template) std::get(std::variant) reads the value of the variant given the index or the type (if the type is unique), throws on error                        (function template) (C++17)