Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
(1)
pair & operator = ( const pair & other ) ;
(hasta C++20)
constexpr pair & operator = ( const pair & other ) ;
(desde C++20)
constexpr const pair & operator = ( const pair & other ) const ;
(2) (desde C++23)
(3)
template < class U1, class U2 >
pair & operator = ( const pair < U1, U2 > & other ) ;
(hasta C++20)
template < class U1, class U2 >
constexpr pair & operator = ( const pair < U1, U2 > & other ) ;
(desde C++20)
template < class U1, class U2 >
constexpr const pair & operator = ( const pair < U1, U2 > & other ) const ;
(4) (desde C++23)
(5)
pair & operator = ( pair && other ) noexcept ( /* see below */ ) ;
(desde C++11)
(hasta C++20)
constexpr pair & operator = ( pair && other ) noexcept ( /* see below */ ) ;
(desde C++20)
constexpr const pair & operator = ( pair && other ) const ;
(6) (desde C++23)
(7)
template < class U1, class U2 >
pair & operator = ( pair < U1, U2 > && p ) ;
(desde C++11)
(hasta C++20)
template < class U1, class U2 >
constexpr pair & operator = ( pair < U1, U2 > && p ) ;
(desde C++20)
template < class U1, class U2 >
constexpr const pair & operator = ( pair < U1, U2 > && p ) const ;
(8) (desde C++23)
template < pair - like P >
constexpr pair & operator = ( P && u ) ;
(9) (desde C++23)
template < pair - like P >
constexpr const pair & operator = ( P && u ) const ;
(10) (desde C++23)

Reemplaza el contenido del par.

1) Operador de asignación de copia. Reemplaza el contenido con una copia del contenido de other .

El operador de asignación se declara implícitamente. Usar este operador de asignación hace que el programa esté mal formado si T1 o T2 es un tipo calificado como const, un tipo referencia, un tipo clase con un operador de asignación de copia inaccesible, o un tipo array de dicha clase.

(hasta C++11)

Esta sobrecarga se define como eliminada si std:: is_copy_assignable < T1 > :: value o std:: is_copy_assignable < T2 > :: value es false .

(desde C++11)
2) Operador de asignación de copia para operando calificado con const.
Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_copy_assignable_v < const T1 > y std:: is_copy_assignable_v < const T2 > son ambos true .
3) Asigna other. first a first y other. second a second .

Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_assignable < T1 & , const U1 & > :: value y std:: is_assignable < T2 & , const U2 & > :: value son ambos true .

(desde C++11)
4) Asigna other. first a first y other. second a second .
Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_assignable_v < const T1 & , const U1 & > y std:: is_assignable_v < const T2 & , const U2 & > son ambos true .
5) Operador de asignación de movimiento. Reemplaza los contenidos con los de other usando semántica de movimiento.
Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_move_assignable < T1 > :: value y std:: is_move_assignable < T2 > :: value son ambos true .
6) Operador de asignación de movimiento para operando calificado como const.
Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_assignable_v < const T1 & , T1 > y std:: is_assignable_v < const T2 & , T2 > son ambos true .
7) Asigna std:: forward < U1 > ( p. first ) a first y std:: forward < U2 > ( p. second ) a second .
Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_assignable < T1 & , U1 > :: value y std:: is_assignable < T2 & , U2 > :: value son ambos true .
8) Asigna std:: forward < U1 > ( p. first ) a first y std:: forward < U2 > ( p. second ) a second .
Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_assignable_v < const T1 & , U1 > y std:: is_assignable_v < const T2 & , U2 > son ambos true .
9) Asigna std :: get < 0 > ( std:: forward < P > ( u ) ) a first y std :: get < 1 > ( std:: forward < P > ( u ) ) a second .
Esta sobrecarga participa en la resolución de sobrecarga solo si
10) Asigna std :: get < 0 > ( std:: forward < P > ( u ) ) a first y std :: get < 1 > ( std:: forward < P > ( u ) ) a second .
Esta sobrecarga participa en la resolución de sobrecarga solo si

Contenidos

Parámetros

other - par de valores para reemplazar el contenido de este par
p - par de valores de posiblemente diferentes tipos para reemplazar el contenido de este par
u - pair-like objeto de valores para reemplazar el contenido de este par
Requisitos de tipo
-
T1 debe cumplir con los requisitos de CopyAssignable desde U1 . (hasta C++11)
-
T2 debe cumplir con los requisitos de CopyAssignable desde U2 . (hasta C++11)

Valor de retorno

* this

Excepciones

1-4) Puede lanzar excepciones definidas por la implementación.
5)
noexcept especificación:
noexcept (

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

)
6-10) Puede lanzar excepciones definidas por la implementación.

Ejemplo

Ejecutar este código 
#include <cstddef>
#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';
}

Salida: 

(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, {}}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 885 C++98 falta asignación de copia heterogénea añadido (como sobrecarga (3) )
LWG 2729 C++11 pair::operator= no estaba restringido y podría
resultar en comportamiento indefinido innecesario 		restringido

Véase también

asigna el contenido de un tuple a otro
(función miembro pública de std::tuple<Types...> )