Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::multimap
Member functions
Non-member functions
Deduction guides (C++17)
multimap & operator = ( const multimap & other ) ;
(1) (constexpr seit C++26)
(2)
multimap & operator = ( multimap && other ) ;
(seit C++11)
(bis C++17)
multimap & operator = ( multimap && other )
noexcept ( /* siehe unten */ ) ;
(seit C++17)
(constexpr seit C++26)
multimap & 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 .

Falls traits :: propagate_on_container_copy_assignment :: value true ist, wird der Allokator von * this durch eine Kopie von other ersetzt. Falls der Allokator von * this nach der Zuweisung ungleich zu seinem alten Wert vergleichen würde, wird der alte Allokator zur Freigabe des Speichers verwendet, danach wird der neue Allokator zur Allokation verwendet bevor die Elemente kopiert werden. 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.

(seit C++11)
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 Speichers von other ü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 Initialisiererliste ilist identifizierten Inhalt.

Inhaltsverzeichnis

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 sich nicht gleich und propagieren nicht, in welchem Fall linear in der Größe von * this und other .
3) O(N·log(N)) im Allgemeinen, wobei N gleich size ( ) + ilist. size ( ) ist. Linear, falls ilist bezüglich value_comp() sortiert ist.

Ausnahmen

2)
noexcept Spezifikation:
noexcept ( std:: allocator_traits < Allocator > :: is_always_equal :: value
&& std:: is_nothrow_move_assignable < Compare > :: value )
(seit C++17)

Hinweise

Nach Container-Verschiebungszuweisung (Überladung ( 2 ) ), sofern keine elementweise Verschiebungszuweisung durch inkompatible Allokatoren erzwungen wird, bleiben Referenzen, Zeiger und Iteratoren (außer dem End-Iterator) auf other gültig, verweisen jedoch auf Elemente, die sich nun in * this befinden. Der aktuelle Standard gibt diese Garantie durch die pauschale Aussage in [container.reqmts]/67 , und eine direktere Garantie wird durch LWG issue 2321 geprüft.

Beispiel

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

Code ausführen 
#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);
}

Ausgabe: 

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

Siehe auch

konstruiert den multimap
(öffentliche Elementfunktion)