std::get(std::pair) (3) Linux Manual Page

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)