Namespaces
Variants

    std::multimap<Key,T,Compare,Allocator>:: operator=

    From es.cppreference.net

    C++
    Containers library
    std::multimap
    Member functions
    Non-member functions
    Deduction guides (C++17)
    multimap & operator = ( const multimap & other ) ;
    		(1) (constexpr desde C++26)
    (2)
    multimap & operator = ( multimap && other ) ;
    		(desde C++11)
    (hasta C++17)
    multimap & operator = ( multimap && other )
    noexcept ( /* ver más abajo */ ) ;
    		(desde C++17)
    (constexpr desde C++26)
    multimap & 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 memoria de * this es reemplazado por una copia de other . Si el asignador de memoria de * this después de la asignación fuera a compararse como desigual con 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 originalmente pertenecientes a * this pueden ser destruidos o reemplazados mediante asignación de copia elemento por elemento.

    		(desde C++11)
    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 propiedad de other y debe reasignar cada elemento individualmente mediante movimiento, 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 reasignación por movimiento elemento por elemento.
    3) Reemplaza el contenido con aquel identificado por la lista de inicialización ilist .

    Contenido

    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) O(N·log(N)) en general, donde N es size ( ) + ilist. size ( ) . Lineal si ilist está ordenado con respecto a value_comp() .

    Excepciones

    2)
    noexcept especificación:
    noexcept ( std:: allocator_traits < Allocator > :: is_always_equal :: value
    && std:: is_nothrow_move_assignable < Compare > :: value )
    		(desde C++17)

    Notas

    Después de la asignación por movimiento del contenedor (sobrecarga (2)), a menos que la asignación por movimiento elemento por elemento sea forzada por asignadores incompatibles, las referencias, punteros e iteradores que originalmente se referían a elementos en other siguen siendo válidos, pero se 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 mediante LWG issue 2321.

    Ejemplo

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

    Ejecutar este código 
    #include <initializer_list>
#include <iostream>
#include <iterator>
#include <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::multimap<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: 

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

    Véase también

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