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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::map

Memberfunktionen

map::map map::~map               map::operator= map::get_allocator

Elementzugriff map::at map::operator[] Iteratoren map::beginmap::cbegin (C++11) map::endmap::cend (C++11) map::rbeginmap::crbegin (C++11)      map::rendmap::crend (C++11) Kapazität map::size map::max_size map::empty Observer map::key_comp map::value_comp Modifizierer map::clear map::insert map::erase map::swap map::extract (C++17) map::merge (C++17) map::insert_range (C++23) map::insert_or_assign (C++17) map::emplace (C++11) map::emplace_hint (C++11) map::try_emplace (C++17) Suche map::count map::find map::contains (C++20) map::equal_range map::lower_bound map::upper_bound

Nicht-Member-Funktionen

operator==operator<=> (C++20) std::swap(std::map) erase_if(std::map) (C++20)   operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)

Leitfaden zur Ableitung (C++17)

 

map& operator=( const map& other );	(1)
	(2)
map& operator=( map&& other );			(seit C++11) (bis C++17)
map& operator=( map&& other ) noexcept(/* siehe unten */);			(seit C++17)
map& 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 Allocator von *this durch eine Kopie von other ersetzt. Wenn der Allocator von *this nach der Zuweisung ungleich seinem alten Wert verglichen würde, wird der alte Allocator verwendet, um den Speicher freizugeben, dann wird der neue Allocator verwendet, um ihn vor dem Kopieren der Elemente zuzuweisen. Andernfalls kann der von *this gehaltene Speicher nach Möglichkeit wiederverwendet werden. In jedem Fall können die ursprünglich zu *this gehörenden Elemente entweder zerstört oder durch elementweise Zuweisung 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 Allocator von *this durch eine Kopie des von other ersetzt. Wenn er false ist und die Allocatoren von *this und other nicht gleich verglichen werden, kann *this den von other gehaltenen Speicher nicht übernehmen und muss jedes Element einzeln verschieben, wobei bei Bedarf zusätzlicher Speicher mit seinem eigenen Allocator zugewiesen wird. In jedem Fall werden alle ursprünglich zu *this gehörenden Elemente entweder zerstört oder durch elementweises Verschieben ersetzt.

3) Ersetzt den Inhalt durch den durch die Initialisierungsliste ilist identifizierten Inhalt.

Parameter

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

Rückgabewert

*this

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 in Bezug auf value_comp() sortiert ist.

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)

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.

Beispiel

Der folgende Code verwendet operator=, um eine std::map 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::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);
}

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

(Konstruktor)

konstruiert die map (public member function)