std::pair(3)

NAME
std::pair - std::pair

Synopsis
   Defined in header <utility>
   template<
       class T1,
       class T2
   > struct pair;
   std::pair is a class 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 neither T1 nor T2 is a possibly cv-qualified class type with non-trivial
   destructor, or array thereof, the destructor of pair is trivial.

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 swaps the contents
   (C++11) (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
   operator<=> (function template)
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (C++20)
   std::swap(std::pair) specializes the std::swap algorithm
   (C++11) (function template)
   get(std::pair) accesses an element of a pair
   (C++11) (function template)

Helper classes
   std::tuple_size<std::pair> obtains the size of a pair
   (C++11) (class template specialization)
   std::tuple_element<std::pair> obtains the type of the elements of pair
   (C++11) (class template specialization)
   std::basic_common_reference<std::pair> determines the common reference type of two
   (C++23) pairs
                        (class template specialization)
   std::common_type<std::pair> determines the common type of two pairs
   (C++23) (class template specialization)
   std::formatter<std::pair> formatting support for pair
   (C++23) (class template specialization)
   Deduction guides(since C++17)
   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 2796 C++98 triviality of the destructor of pair was specified
                       unspecified

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