Namespaces
Variants

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

De es.cppreference.net
 
 
Biblioteca de utilidades
Soporte del lenguaje
Soporte de tipos (tipos básicos, RTTI)
Macros de prueba de funcionalidades de la biblioteca (C++20)
Utilidades del programa
Funciones variádicas
Soporte de corrutinas (C++20)
Soporte de contratos (C++26)
Comparación de tres vías
(C++20)
(C++20)(C++20)(C++20)    
(C++20)(C++20)(C++20)

Utilidades generales
Operadores relacionales (obsoleto en C++20)
Funciones de comparación de enteros
(C++20)(C++20)(C++20)    
(C++20)
Intercambio y operaciones de tipo
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
Tipos de vocabulario comunes
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)



 
 
pair& operator=( const pair& other );
(1) (constexpr desde C++20)
constexpr const pair& operator=( const pair& other ) const;
(2) (desde C++23)
template< class U1, class U2 >
pair& operator=( const pair<U1, U2>& other );
(3) (constexpr desde C++20)
template< class U1, class U2 >
constexpr const pair& operator=( const pair<U1, U2>& other ) const;
(4) (desde C++23)
pair& operator=( pair&& other ) noexcept(/* see below */);
(5) (desde C++11)
(constexpr desde C++20)
constexpr const pair& operator=( pair&& other ) const;
(6) (desde C++23)
template< class U1, class U2 >
pair& operator=( pair<U1, U2>&& p );
(7) (desde C++11)
(constexpr 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 por copia. Reemplaza el contenido con una copia del contenido de other.

El operador de asignación se declara implícitamente. El uso de este operador de asignación hace que el programa esté mal formado si T1 o T2 es un tipo calificado como const, o un tipo de referencia, o un tipo de clase con un operador de asignación por copia inaccesible, o un tipo de arreglo 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 por copia para operando calificado como 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 por movimiento. Reemplaza el contenido con el 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 por 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
  • std::same_as<std::remove_cvref_t<P>, std::pair> es false,
  • std::remove_cvref_t<P> no es una especialización de std::ranges::subrange,
  • std::is_assignable_v<T1&, decltype(std::get<0>(std::forward<P>(p)))> es true, y
  • std::is_assignable_v<T1&, decltype(std::get<1>(std::forward<P>(p)))> es true.
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
  • std::same_as<std::remove_cvref_t<P>, std::pair> es false,
  • std::remove_cvref_t<P> no es una especialización de std::ranges::subrange,
  • std::is_assignable_v<const T1&, decltype(std::get<0>(std::forward<P>(p)))> es true, y
  • std::is_assignable_v<const T1&, decltype(std::get<1>(std::forward<P>(p)))> es true.

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

#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...> )