std::pair::operator=(3)

NAME
std::pair::operator= - std::pair::operator=

Synopsis
   pair& operator=( const pair& other ); (until
                        C++20)
   constexpr pair& operator=( const pair& other (since
   ); C++20)
   constexpr const pair& operator=( const pair& (2) (since
   other ) const; C++23)
   template< class U1, class U2 > (since
   pair& operator=( const pair<U1, U2>& other C++11)
   ); (until
                        C++20)
   template< class U1, class U2 > (since
   constexpr pair& operator=( const pair<U1, C++20)
   U2>& other );
   template< class U1, class U2 > (since
   constexpr const pair& operator=( const (4) C++23)
   pair<U1, U2>& other ) const;
                        (1) (since
   pair& operator=( pair&& other ) noexcept(/* C++11)
   see below */); (until
                        (3) C++20)
   constexpr pair& operator=( pair&& other ) (since
   noexcept(/* see below */); C++20)
   constexpr const pair& operator=( pair&& (6) (since
   other ) const; C++23)
                        (5) (since
   template< class U1, class U2 > C++11)
   pair& operator=( pair<U1, U2>&& other ); (until
                        C++20)
   template< class U1, class U2 > (7) (since
   constexpr pair& operator=( pair<U1, U2>&& C++20)
   other );
   template< class U1, class U2 > (since
   constexpr const pair& operator=( pair<U1, (8) C++23)
   U2>&& other ) const;
   Replaces the contents of the pair.
   1) Copy assignment operator. Replaces the contents with a copy of the contents of
   other.
     * The assignment operator is implicitly declared. Using this
       assignment operator makes the program ill-formed if either T1 or
       T2 is a const-qualified type, or a reference type, or a class type (until C++11)
       with an inaccessible copy assignment operator, or an array type of
       such class.
     * This overload is defined as deleted if either
       std::is_copy_assignable<T1>::value or (since C++11)
       std::is_copy_assignable<T2>::value is false.
   2) Copy assignment operator for const-qualified operand.
     * This overload participates in overload resolution only if
       std::is_copy_assignable_v<const T1> and std::is_copy_assignable_v<const T2> are
       both true.
   3) Assigns other.first to first and other.second to second.
     * This overload participates in overload resolution only if
       std::is_assignable<T1&, const U1&>::value and std::is_assignable<T2&, const
       U2&>::value are both true.
   4) Assigns other.first to first and other.second to second.
     * This overload participates in overload resolution only if
       std::is_assignable_v<const T1&, const U1&> and std::is_assignable_v<const T2&,
       const U2&> are both true.
   5) Move assignment operator. Replaces the contents with those of other using move
   semantics.
     * This overload participates in overload resolution only if
       std::is_move_assignable<T1>::value and std::is_move_assignable<T2>::value are
       both true.
   6) Move assignment operator for const-qualified operand.
     * This overload participates in overload resolution only if
       std::is_assignable_v<const T1&, T1> and std::is_assignable_v<const T2&, T2> are
       both true.
   7) Assigns std::forward<U1>(p.first) to first and std::forward<U2>(p.second) to
   second.
     * This overload participates in overload resolution only if
       std::is_assignable<T1&, U1>::value and std::is_assignable<T2&, U2>::value are
       both true.
   8) Assigns std::forward<U1>(p.first) to first and std::forward<U2>(p.second) to
   second.
     * This overload participates in overload resolution only if
       std::is_assignable_v<const T1&, U1> and std::is_assignable_v<const T2&, U2> are
       both true.

Parameters
   other - pair of values to replace the contents of this pair

Return value
   *this

Exceptions
   1-4) May throw implementation-defined exceptions.
   5)
   noexcept specification:
   noexcept(
   std::is_nothrow_move_assignable<T1>::value &&
   std::is_nothrow_move_assignable<T2>::value
   )
   6-8) May throw implementation-defined exceptions.

Example
// Run this code
 #include <iomanip>
 #include <iostream>
 #include <utility>
 #include <vector>
 template <class Os, class T>
 Os& operator<<(Os& os, const std::vector<T>& v) {
     os << "{";
     for (std::size_t t = 0; t != v.size(); ++t)
         os << v[t] << (t+1 < v.size() ? "," : "");
     return os << "}";
 }
 template <class Os, class U1, class U2>
 Os& operator<<(Os& os, const std::pair<U1, U2>& pair) {
     return os << ":{ " << pair.first << ", " << pair.second << " } ";
 }
 int main()
 {
     std::pair<int, std::vector<int>> p{ 1, {2} }, q{ 2, {5,6} };
     p = q; // (1) operator=( const pair& other );
     std::cout << std::setw(23) << std::left
               << "(1) p = q;" << "p" << p << " q" << q << '\n';
     std::pair<short, std::vector<int>> r{ 4, {7,8,9} };
     p = r; // (3) operator=( const pair<U1,U2>& other );
     std::cout << std::setw(23)
               << "(3) p = r;" << "p" << p << " r" << r << '\n';
     p = std::pair<int, std::vector<int>>{ 3, {4} };
     p = std::move(q); // (5) operator=( pair&& other );
     std::cout << std::setw(23)
               << "(5) p = std::move(q);" << "p" << p << " q" << q << '\n';
     p = std::pair<int, std::vector<int>>{ 5, {6} };
     p = std::move(r); // (7) operator=( pair<U1,U2>&& other );
     std::cout << std::setw(23)
               << "(7) p = std::move(r);" << "p" << p << " r" << r << '\n';
 }

Output:
 (1) p = q; p:{ 2, {5,6} } q:{ 2, {5,6} }
 (3) p = r; p:{ 4, {7,8,9} } r:{ 4, {7,8,9} }
 (5) p = std::move(q); p:{ 2, {5,6} } q:{ 2, {} }
 (7) p = std::move(r); p:{ 4, {7,8,9} } r:{ 4, {} }
  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 2729 C++11 pair::operator= was unconstrained and might constrained
                       result in unnecessary undefined behavior

See also
   operator= assigns the contents of one tuple to another
   (C++11) (public member function of std::tuple<Types...>)