std::pair

Defined in header `<utility>`
template< class T1, class T2 > struct pair;

std::pair is a struct template that provides a way to store two heterogeneous objects as a single unit. A pair is a specific case of a std::tuple with two elements.

If std::is_trivially_destructible_v<T1> && std::is_trivially_destructible_v<T2> is true, the destructor of pair is trivial.

(since C++17)

Template parameters

T1, T2

the types of the elements that the pair stores.

Member types

Member type	Definition
`first_type`	`T1`
`second_type`	`T2`

Member objects

Member name	Type
`first`	`T1`
`second`	`T2`

Member functions

(constructor)	constructs new pair (public member function)
operator=	assigns the contents (public member function)
swap (C++11)	swaps the contents (public member function)

Non-member functions

make_pair	creates a `pair` object of type, defined by the argument types (function template)
operator==operator!=operator<operator<=operator>operator>=	lexicographically compares the values in the pair (function template)
std::swap(std::pair) (C++11)	specializes the `std::swap` algorithm (function template)
std::get(std::pair) (C++11)	accesses an element of a `pair` (function template)

Helper classes

std::tuple_size<std::pair> (C++11)	obtains the size of a `pair` (class template specialization)
std::tuple_element<std::pair> (C++11)	obtains the type of the elements of `pair` (class template specialization)

tuple (C++11)	implements fixed size container, which holds elements of possibly different types (class template)
tie	creates a `tuple` of lvalue references or unpacks a tuple into individual objects (function template)