Namespaces
Variants

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: operator=

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
unordered_map & operator = ( const unordered_map & other ) ;
(1) (desde C++11)
(constexpr desde C++26)
(2)
unordered_map & operator = ( unordered_map && other ) ;
(desde C++11)
(hasta C++17)
unordered_map & operator = ( unordered_map && other )
noexcept ( /* ver más abajo */ ) ;
(desde C++17)
(constexpr desde C++26)
unordered_map & operator = ( std:: initializer_list < value_type > ilist ) ;
(3) (desde C++11)
(constexpr desde C++26)

Reemplaza el contenido del contenedor.

Sea traits como std:: allocator_traits < allocator_type > :

1) Operador de asignación de copia. Reemplaza el contenido con una copia del contenido de other .
Si traits :: propagate_on_container_copy_assignment :: value es true , el asignador de * this se reemplaza por una copia de other . Si el asignador de * this después de la asignación fuera a compararse como desigual a su valor anterior, el asignador anterior se utiliza para desasignar la memoria, luego el nuevo asignador se utiliza para asignarla antes de copiar los elementos. De lo contrario, la memoria propiedad de * this puede reutilizarse cuando sea posible. En cualquier caso, los elementos que originalmente pertenecían a * this pueden ser destruidos o reemplazados mediante asignación de copia elemento por elemento.
2) Operador de asignación de movimiento. Reemplaza el contenido con el de other usando semántica de movimiento (es decir, los datos en other son movidos desde other hacia este contenedor). other queda en un estado válido pero no especificado después.
Si traits :: propagate_on_container_move_assignment :: value es true , el asignador de memoria de * this es reemplazado por una copia del de other . Si es false y los asignadores de memoria de * this y other no son iguales, * this no puede tomar posesión de la memoria poseída por other y debe asignar por movimiento cada elemento individualmente, asignando memoria adicional usando su propio asignador según sea necesario. En cualquier caso, todos los elementos que originalmente pertenecían a * this son destruidos o reemplazados mediante asignación por movimiento elemento a elemento.
3) Reemplaza el contenido con aquel identificado por la lista de inicialización ilist .

Contenidos

Parámetros

other - otro contenedor para usar como fuente de datos
ilist - lista de inicializadores para usar como fuente de datos

Valor de retorno

* this

Complejidad

1) Lineal en el tamaño de * this y other .
2) Lineal en el tamaño de * this a menos que los asignadores no sean iguales y no se propaguen, en cuyo caso lineal en el tamaño de * this y other .
3) Lineal en el tamaño de * this y ilist .

Excepciones

2)
noexcept especificación:
noexcept ( std:: allocator_traits < Allocator > :: is_always_equal :: value

&& std:: is_nothrow_move_assignable < Hash > :: value

&& std:: is_nothrow_move_assignable < Pred > :: value )
(desde C++17)

Notas

Después de la asignación de movimiento del contenedor (sobrecarga ( 2 ) ), a menos que la asignación de movimiento elemento por elemento sea forzada por asignadores incompatibles, las referencias, punteros e iteradores (excepto el iterador final) a other permanecen válidos, pero refieren a elementos que ahora están en * this . El estándar actual garantiza esto mediante la declaración general en [container.reqmts]/67 , y se está considerando una garantía más directa a través de LWG issue 2321 .

Ejemplo

El siguiente código utiliza operator = para asignar un std::unordered_map a otro:

Ejecutar este código 
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <unordered_map>
#include <utility>
void print(const auto comment, const auto& container)
{
    auto size = std::size(container);
    std::cout << comment << "{ ";
    for (const auto& [key, value] : container)
        std::cout << '{' << key << ',' << value << (--size ? "}, " : "} ");
    std::cout << "}\n";
}
int main()
{
    std::unordered_map<int, int> x{{1,1}, {2,2}, {3,3}}, y, z;
    const auto w = {std::pair<const int, int>{4,4}, {5,5}, {6,6}, {7,7}};
    std::cout << "Initially:\n";
    print("x = ", x);
    print("y = ", y);
    print("z = ", z);
    std::cout << "Copy assignment copies data from x to y:\n";
    y = x;
    print("x = ", x);
    print("y = ", y);
    std::cout << "Move assignment moves data from x to z, modifying both x and z:\n";
    z = std::move(x);
    print("x = ", x);
    print("z = ", z);
    std::cout << "Assignment of initializer_list w to z:\n";
    z = w;
    print("w = ", w);
    print("z = ", z);
}

Salida posible: 

Initially:
x = { {3,3}, {2,2}, {1,1} }
y = { }
z = { }
Copy assignment copies data from x to y:
x = { {3,3}, {2,2}, {1,1} }
y = { {3,3}, {2,2}, {1,1} }
Move assignment moves data from x to z, modifying both x and z:
x = { }
z = { {3,3}, {2,2}, {1,1} }
Assignment of initializer_list w to z:
w = { {4,4}, {5,5}, {6,6}, {7,7} }
z = { {7,7}, {6,6}, {5,5}, {4,4} }

Véase también

construye el unordered_map
(función miembro pública)