Namespaces
Variants

    std::unordered_set<Key,Hash,KeyEqual,Allocator>:: operator=

    From de.cppreference.net

    C++
    Containers library
    std::unordered_set
    Member types
    Member functions
    Non-member functions
    Deduction guides (C++17)
    unordered_set & operator = ( const unordered_set & other ) ;
    		(1) (seit C++11)
    (constexpr seit C++26)
    (2)
    unordered_set & operator = ( unordered_set && other ) ;
    		(seit C++11)
    (bis C++17)
    unordered_set & operator = ( unordered_set && other )
    noexcept ( /* siehe unten */ ) ;
    		(seit C++17)
    (constexpr seit C++26)
    unordered_set & operator = ( std:: initializer_list < value_type > ilist ) ;
    		(3) (seit C++11)
    (constexpr seit C++26)

    Ersetzt den Inhalt des Containers.

    Sei traits gleich std:: allocator_traits < allocator_type > :

    1) Kopierzuweisungsoperator. Ersetzt den Inhalt durch eine Kopie des Inhalts von other .
    Wenn traits :: propagate_on_container_copy_assignment :: value true ist, wird der Allokator von * this durch eine Kopie von other ersetzt. Wenn der Allokator von * this nach der Zuweisung ungleich zu seinem alten Wert verglichen würde, wird der alte Allokator verwendet, um den Speicher freizugeben, dann wird der neue Allokator verwendet, um ihn vor dem Kopieren der Elemente zu allozieren. Andernfalls kann der von * this verwaltete Speicher wenn möglich wiederverwendet werden. In jedem Fall können die ursprünglich zu * this gehörenden Elemente entweder zerstört oder durch elementweise Kopierzuweisung ersetzt werden.
    2) Move-Zuweisungsoperator. Ersetzt die Inhalte durch die von other unter Verwendung von Move-Semantik (d.h. die Daten in other werden von other in diesen Container verschoben). other befindet sich danach in einem gültigen aber unspezifizierten Zustand.
    Wenn traits :: propagate_on_container_move_assignment :: value true ist, wird der Allokator von * this durch eine Kopie des Allokators von other ersetzt. Wenn er false ist und die Allokatoren von * this und other nicht gleich sind, kann * this nicht den Besitz des von other belegten Speichers übernehmen und muss jedes Element einzeln per Move-Zuweisung übertragen, wobei bei Bedarf zusätzlicher Speicher mit dem eigenen Allokator allokiert wird. In jedem Fall werden alle Elemente, die ursprünglich zu * this gehörten, entweder zerstört oder durch elementweise Move-Zuweisung ersetzt.
    3) Ersetzt den Inhalt durch den durch die Initialisierungsliste ilist identifizierten Inhalt.

    Inhalt

    Parameter

    other - ein anderer Container, der als Datenquelle verwendet werden soll
    ilist - Initialisierungsliste, die als Datenquelle verwendet werden soll

    Rückgabewert

    * this

    Komplexität

    1) Linear in der Größe von * this und other .
    2) Linear in der Größe von * this , es sei denn, die Allokatoren vergleichen nicht gleich und propagieren nicht, in welchem Fall linear in der Größe von * this und other .
    3) Linear in der Größe von * this und ilist .

    Exceptions

    2)
    noexcept Spezifikation:
    noexcept ( std:: allocator_traits < Allocator > :: is_always_equal :: value

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

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

    Anmerkungen

    Nach der Move-Zuweisung eines Containers (Überladung (2)), sofern nicht aufgrund inkompatibler Allokatoren eine elementweise Move-Zuweisung erzwungen wird, bleiben Verweise, Zeiger und Iteratoren, die sich ursprünglich auf Elemente in other bezogen, gültig, verweisen aber nun auf Elemente, die sich jetzt in *this befinden. Der aktuelle Standard gewährleistet dies durch die pauschale Aussage in [container.reqmts]/67, und eine direktere Garantie wird erwogen mittels LWG issue 2321.

    Beispiel

    Der folgende Code verwendet den operator = , um einen std::unordered_set einem anderen zuzuweisen:

    Diesen Code ausführen 
    #include <initializer_list>
#include <iostream>
#include <iterator>
#include <unordered_set>
void print(const auto comment, const auto& container)
{
    auto size = std::size(container);
    std::cout << comment << "{ ";
    for (const auto& element : container)
        std::cout << element << (--size ? ", " : " ");
    std::cout << "}\n";
}
int main()
{
    std::unordered_set<int> x{1, 2, 3}, y, z;
    const auto w = {4, 5, 6, 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);
}

    Mögliche Ausgabe: 

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

    Siehe auch

    		Konstruiert den unordered_set
    (öffentliche Member-Funktion)