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

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Library feature-test macros
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
integer_sequence (C++14)
Relational operators (deprecated in C++20)
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Comparisons (C++20)
strong_order weak_order partial_order strong_equal weak_equal	strong_ordering weak_ordering partial_ordering strong_equality weak_equality	is_eqis_neqis_ltis_lteqis_gtis_gteq
common_comparison_category
Common vocabulary types
pair tuple (C++11) apply (C++17) make_from_tuple (C++17)	optional (C++17) any (C++17) variant (C++17)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
Elementary string conversions
to_chars (C++17)
from_chars (C++17)
chars_format (C++17)
Type operations
declval (C++11)
as_const (C++17)
launder (C++17)

 

std::pair

Member functions

pair::pair

pair::operator=

pair::swap

Non-member functions

make_pair

operator==operator!=operator<operator<=operator>operator>=

std::swap

get (C++11)

Deduction guides(C++17)

Helper classes

tuple_size (C++11)

tuple_element (C++11)

 

	(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)