Namespaces
Variants

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

    From fr.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) (depuis C++11)
    (constexpr depuis C++26)
    (2)
    unordered_map & operator = ( unordered_map && other ) ;
    		(depuis C++11)
    (jusqu'à C++17)
    unordered_map & operator = ( unordered_map && other )
    noexcept ( /* voir ci-dessous */ ) ;
    		(depuis C++17)
    (constexpr depuis C++26)
    unordered_map & operator = ( std:: initializer_list < value_type > ilist ) ;
    		(3) (depuis C++11)
    (constexpr depuis C++26)

    Remplace le contenu du conteneur.

    Soit traits le std:: allocator_traits < allocator_type > :

    1) Opérateur d'affectation par copie. Remplace le contenu par une copie du contenu de other .
    Si traits :: propagate_on_container_copy_assignment :: value est true , l'allocateur de * this est remplacé par une copie de other . Si l'allocateur de * this après l'affectation serait différent de son ancienne valeur, l'ancien allocateur est utilisé pour désallouer la mémoire, puis le nouvel allocateur est utilisé pour l'allouer avant de copier les éléments. Sinon, la mémoire appartenant à * this peut être réutilisée lorsque possible. Dans tous les cas, les éléments appartenant initialement à * this peuvent être soit détruits soit remplacés par une affectation-copie élément par élément.
    2) Opérateur d'affectation par déplacement. Remplace le contenu par celui de other en utilisant la sémantique de déplacement (c'est-à-dire que les données dans other sont déplacées de other vers ce conteneur). other se trouve dans un état valide mais non spécifié par la suite.
    Si traits :: propagate_on_container_move_assignment :: value est true , l'allocateur de * this est remplacé par une copie de celui de other . S'il est false et que les allocateurs de * this et other ne sont pas égaux, * this ne peut pas prendre possession de la mémoire appartenant à other et doit assigner par déplacement chaque élément individuellement, en allouant de la mémoire supplémentaire en utilisant son propre allocateur si nécessaire. Dans tous les cas, tous les éléments appartenant initialement à * this sont soit détruits soit remplacés par une assignation par déplacement élément par élément.
    3) Remplace le contenu par celui identifié par la liste d'initialisation ilist .

    Contenu

    Paramètres

    other - autre conteneur à utiliser comme source de données
    ilist - liste d'initialisation à utiliser comme source de données

    Valeur de retour

    * this

    Complexité

    1) Linéaire dans la taille de * this et other .
    2) Linéaire dans la taille de * this sauf si les allocateurs ne sont pas égaux et ne se propagent pas, auquel cas linéaire dans la taille de * this et other .
    3) Linéaire dans la taille de * this et ilist .

    Exceptions

    2)
    noexcept spécification :
    noexcept ( std:: allocator_traits < Allocator > :: is_always_equal :: value

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

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

    Notes

    Après l'affectation par déplacement de conteneur (surcharge (2)), sauf si l'affectation par déplacement élément par élément est forcée par des allocateurs incompatibles, les références, pointeurs et itérateurs qui se référaient initialement aux éléments dans other restent valides, mais se réfèrent aux éléments qui sont maintenant dans *this. La norme actuelle donne cette garantie via l'énoncé général dans [container.reqmts]/67, et une garantie plus directe est à l'étude via LWG issue 2321.

    Exemple

    Le code suivant utilise operator = pour assigner un std::unordered_map à un autre :

    Exécuter ce code 
    #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);
}

    Sortie possible : 

    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} }

    Voir aussi

    		construit l' unordered_map
    (fonction membre publique)