Namensräume
Varianten
Aktionen

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

Von cppreference.com
< cpp‎ | container‎ | multimap

[Bearbeiten-Vorlage]
 
C++
 
Container-Bibliothek
 
std::multimap
Memberfunktionen
Nicht-Member-Funktionen
(bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduction guides(C++17)
 
multimap& operator=( const multimap& other );
 (1)
(2)
multimap& operator=( multimap&& other );
 (seit C++11)
(bis C++17)
multimap& operator=( multimap&& other ) noexcept( /* see below */ );
 (seit C++17)
multimap& operator=( std::initializer_list<value_type> ilist );
 (3) (seit C++11)

Ersetzt den Inhalt des Containers.

1) Kopierzuweisungsoperator. Ersetzt den Inhalt durch eine Kopie des Inhalts von other.

Wenn std::allocator_traits<allocator_type>::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 seinem alten Wert wäre, wird der alte Allokator zum Deallokieren des Speichers verwendet, dann wird der neue Allokator zum Allokieren vor dem Kopieren der Elemente verwendet. Andernfalls kann der von *this gehaltene Speicher wiederverwendet werden, wo immer dies möglich ist. 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 den Inhalt durch den 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 unbestimmten Zustand.
Wenn std::allocator_traits<allocator_type>::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 den von other gehaltenen Speicher nicht übernehmen und muss jedes Element einzeln per Move-Zuweisung zuweisen, wobei bei Bedarf zusätzlicher Speicher mit dem eigenen Allokator alloziert wird. In jedem Fall werden alle ursprünglich zu *this gehörenden Elemente entweder zerstört oder durch elementweise Move-Zuweisung ersetzt.
3) Ersetzt den Inhalt durch den durch die Initialisierungsliste ilist identifizierten Inhalt.

Inhalt

[bearbeiten] Parameter

Sonstiges - ein weiterer Container, der als Datenquelle dient
ilist - Initialisierungsliste, die als Datenquelle dient

[bearbeiten] Rückgabewert

*this

[bearbeiten] Komplexität

1) Linear zur Größe von *this und other.
2) Linear zur Größe von *this, es sei denn, die Allokatoren sind nicht gleich und propagieren nicht, in diesem Fall linear zur Größe von *this und other.
3) O(NlogN) im Allgemeinen, wobei N size() + ilist.size() ist. Linear, wenn ilist bezüglich value_comp() sortiert ist.

[bearbeiten] Ausnahmen

1-3) Kann Implementierungs-definierte Ausnahmen auslösen.
 (bis C++17)
1,3) Kann implementierungsdefinierte Ausnahmen auslösen.
2)
noexcept-Spezifikation:  
noexcept(std::allocator_traits<Allocator>::is_always_equal::value
&& std::is_nothrow_move_assignable<Compare>::value)
 (seit C++17)

[bearbeiten] Hinweise

Nach der Container-Move-Zuweisung (Überladung (2)), es sei denn, die elementweise Move-Zuweisung wird durch inkompatible Allokatoren erzwungen, bleiben Referenzen, Zeiger und Iteratoren (außer dem End-Iterator) zu other gültig, verweisen aber auf Elemente, die sich jetzt in *this befinden. Der aktuelle Standard macht diese Garantie durch die allgemeine Aussage in [container.reqmts]/67 und eine direktere Garantie wird durch LWG issue 2321 in Betracht gezogen.

[bearbeiten] Beispiel

Der folgende Code verwendet operator=, um eine std::multimap einer anderen zuzuweisen.

Führen Sie diesen Code aus
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <map>
#include <utility>
 
void print(auto const comment, auto const& container)
{
    auto size = std::size(container);
    std::cout << comment << "{ ";
    for (auto const& [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} }

[bearbeiten] Siehe auch

 konstruiert die multimap
(public member function) [edit]
Zurück von "https://cppreference.de/mwiki/index.php?title=cpp/container/multimap/operator%3D&oldid=136087"