# std::pair<T1,T2>::operator=

From cppreference.com
< cpp‎ | utility‎ | pair

| (1) |
pair& operator=( const pair& other ); |  | (until C++20)
constexpr pair& operator=( const pair& other ); |  | (since C++20)
| (2) |
template< class U1, class U2 > pair& operator=( const pair<U1,U2>& other ); |  | (until C++20)
template< class U1, class U2 > constexpr pair& operator=( const pair<U1,U2>& other ); |  | (since C++20)
| (3) |
pair& operator=( pair&& other ) noexcept(/* see below */); |  | (since C++11) (until C++20)
constexpr pair& operator=( pair&& other ) noexcept(/* see below */); |  | (since C++20)
| (4) |
template< class U1, class U2 > pair& operator=( pair<U1,U2>&& other ); |  | (since C++11) (until C++20)
template< class U1, class U2 > constexpr pair& operator=( pair<U1,U2>&& other ); |  | (since C++20)

Replaces the contents of the pair.

1) Copy assignment operator. Replaces the contents with a copy of the contents of other.
2) Assigns `other.first` to `first` and `other.second` to `second`
3) Move assignment operator. Replaces the contents with those of `other` using move semantics.
4) Assigns std::forward <U1>(p.first) to `first` and std::forward <U2>(p.second) to `second`.

The behavior of these functions is undefined unless:

- For (1),std::is_copy_assignable <first_type>::value and std::is_copy_assignable <second_type>::value are both true.
- For (2),std::is_assignable <first_type&, const U1&>::value and std::is_assignable <second_type&, const U2&>::value are both true.
- For (3),std::is_move_assignable <first_type>::value and std::is_move_assignable <second_type>::value are both true.
- For (4),std::is_assignable <first_type&, U1&&>::value and std::is_assignable <second_type&, U2&&>::value are both true.

(until C++17)

These functions do not participate in overload resolution (or, for the copy assignment operator, is defined as deleted) if any required assignment operation is invalid. Specifically:

- (1) is defined as deleted unless std::is_copy_assignable_v <first_type> and std::is_copy_assignable_v <second_type> are both true.
- (2) does not participate in overload resolution unless std::is_assignable_v <first_type&, const U1&> and std::is_assignable_v <second_type&, const U2&> are both true.
- (3) does not participate in overload resolution unless std::is_move_assignable_v <first_type> and std::is_move_assignable_v <second_type> are both true.
- (4) does not participate in overload resolution unless std::is_assignable_v <first_type&, U1&&> and std::is_assignable_v <second_type&, U2&&> are both true.

(since C++17)

### Parameters

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

### Return value

*this

### Exceptions

1-2) (none)
3)
`noexcept` specification:
noexcept(

is_nothrow_move_assignable<T1>::value &&
is_nothrow_move_assignable<T2>::value

)
4) (none)

### Example

| This section is incomplete Reason: no example

### See also

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/pair/operator%3D&oldid=107580"