Espacios de nombres
Variantes

    std::pair::operator=

    De cppreference.com
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos denominados
    Macros de prueba de característica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnósticos
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de servicios generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de servicios
     
    std::pair
    Funciones miembro
    Funciones no miembro
    (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20)
    (C++11)
    Guías de deducción(C++17)
    Clases auxiliares
    (C++11)
    (C++11)
     
    <tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>
    (1)
    pair& operator=( const pair& other );
    		 (hasta C++20)
    constexpr pair& operator=( const pair& other );
    		 (desde C++20)
    (2)
    template< class U1, class U2 > pair& operator=( const pair<U1,U2>& other );
    		 (desde C++11)
    (hasta C++20)
    template< class U1, class U2 > constexpr pair& operator=( const pair<U1,U2>& other );
    		 (desde C++20)
    (3)
    pair& operator=( pair&& other ) noexcept(/* véase más abajo */);
    		 (desde C++11)
    (hasta C++20)
    constexpr pair& operator=( pair&& other ) noexcept(/* véase más abajo */);
    		 (desde C++20)
    (4)
    template< class U1, class U2 > pair& operator=( pair<U1,U2>&& other );
    		 (desde C++11)
    (hasta C++20)
    template< class U1, class U2 > constexpr pair& operator=( pair<U1,U2>&& other );
    		 (desde C++20)

    Reemplaza el contenido de un par.

    1) Operador de asignación de copia. Reemplaza el contenido con una copia del contenido de other.
    • El operador de asignación está declarado implícitamente. Usar este operador de asignación hace que el programa esté mal formado si ya sea first_type o second_type es un tipo calificado const, o un tipo referencia, o un tipo clase con un operador de asignación de copia inaccessible, o un tipo array de tal clase.
    		 (hasta C++11)
    • Esta sobrecarga se define como eliminada si ya sea std::is_copy_assignable<first_type>::value o std::is_copy_assignable<second_type>::value es false.
    		 (desde C++11)
    2) Asigna other.first a first y other.second a second.
    • Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_assignable<first_type&, const U1&>::value y std::is_assignable<second_type&, const U2&>::value son true.
    3) Operador de asignación de movimiento. Reemplaza el contenido con el de other usando semántica de movimiento.
    • Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_move_assignable<first_type>::value y std::is_move_assignable<second_type>::value son true.
    4) Asigna std::forward<U1>(p.first) a first y std::forward<U2>(p.second) a second.
    • Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_assignable<first_type&, U1>::value y std::is_assignable<second_type&, U2>::value son true.

    Parámetros

    other - Par de valores con el cual reemplazar el contenido de este par.

    Valor de retorno

    *this

    Excepciones

    1-2) (Ninguna)
    3)
    Especificación noexcept:   (desde C++11)
    <tbody> </tbody>
    noexcept( std::is_nothrow_move_assignable<T1>::value && std::is_nothrow_move_assignable<T2>::value )
    4) (Ninguna)

    Ejemplo

    Ejecuta este código
    #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(19) << std::left
              << "p = q;" << "p" << p << "   q" << q << '\n';

    p = std::pair<int, std::vector<int>>{ 3, {4} };
    p = std::move(q); // (2) operator=( const pair<U1,U2>& other );
    std::cout << std::setw(19)
              << "p = std::move(q);" << "p" << p << "   q" << q << '\n';

    std::pair<short, std::vector<int>> r{ 4, {7,8,9} };
    p = r; // (3) operator=( pair&& other );
    std::cout << std::setw(19)
              << "p = r;" << "p" << p << " r" << r << '\n';

    p = std::pair<int, std::vector<int>>{ 5, {6} };
    p = std::move(r); // (4) operator=( pair<U1,U2>&& other );
    std::cout << std::setw(19)
              << "p = std::move(r);" << "p" << p << " r" << r << '\n';
}

    Salida: 

    p = q;             p:{ 2, {5,6} }    q:{ 2, {5,6} } 
p = std::move(q);  p:{ 2, {5,6} }    q:{ 2, {} } 
p = r;             p:{ 4, {7,8,9} }  r:{ 4, {7,8,9} } 
p = std::move(r);  p:{ 4, {7,8,9} }  r:{ 4, {} }

    Informes de defectos

    Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

    ID Aplicado a Comportamiento según lo publicado Comportamiento correcto
    LWG 2729 C++11 pair::operator= no estaba restringido y podría
    resultar en comportamiento indefinido innecesario.     		Restringido.

    Véase también