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)

 

T& operator[]( const Key& key );	(1)
T& operator[]( Key&& key );	(2)	(seit C++11)
template< class K > T& operator[]( K&& x );	(3)	(seit C++26)

Gibt eine Referenz auf den Wert zurück, der einem Schlüssel entspricht, der gleich key bzw. x ist, und führt eine Einfügung durch, falls ein solcher Schlüssel noch nicht existiert.

1) Fügt ein value_type(key, T()) ein, falls der Schlüssel nicht existiert. - key_type muss die Anforderungen von CopyConstructible erfüllen. - mapped_type muss die Anforderungen von CopyConstructible und DefaultConstructible erfüllen. Falls eine Einfügung durchgeführt wird, wird der zugeordnete Wert wertinitialisiert (für Klassentypen standardkonstruiert, sonst nullinitialisiert) und ein Verweis darauf zurückgegeben.

(bis C++11)

1) Fügt ein value_type-Objekt ein, das aus std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() in-place konstruiert wird, falls der Schlüssel nicht existiert. Entspricht return this->try_emplace(key).first->second;.(seit C++17)Bei Verwendung des Standardallokators wird der Schlüssel aus key kopierkonstruiert und der zugeordnete Wert wertinitialisiert. - value_type muss EmplaceConstructible aus std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() sein. Bei Verwendung des Standardallokators bedeutet dies, dass key_type CopyConstructible und mapped_type DefaultConstructible sein muss. 2) Fügt ein value_type-Objekt ein, das aus std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>() in-place konstruiert wird, falls der Schlüssel nicht existiert. Entspricht return this->try_emplace(std::move(key)).first->second;.(seit C++17) Bei Verwendung des Standardallokators wird der Schlüssel aus key move-konstruiert und der zugeordnete Wert wertinitialisiert. - value_type muss EmplaceConstructible aus std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>() sein. Bei Verwendung des Standardallokators bedeutet dies, dass key_type MoveConstructible und mapped_type DefaultConstructible sein muss.

(seit C++11)

3) Fügt ein value_type-Objekt in-place ein, falls es keinen Schlüssel gibt, der transparent äquivalent zu dem Wert x ist.

Entspricht return this->try_emplace(std::forward<K>(x)).first->second;. Dieser Überladungsfall nimmt an der Auflösung von Überladungen nur teil, wenn der qualifizierte Bezeichner Compare::is_transparent gültig ist und einen Typ bezeichnet. Er ermöglicht das Aufrufen dieser Funktion, ohne eine Instanz von Key zu konstruieren.

Keine Iteratoren oder Referenzen werden ungültig.

Parameter

key	-	der Schlüssel des zu findenden Elements
x	-	ein Wert eines beliebigen Typs, der transparent mit einem Schlüssel verglichen werden kann

Rückgabewert

1,2) Eine Referenz auf den zugeordneten Wert des neuen Elements, wenn kein Element mit dem Schlüssel key existierte. Andernfalls eine Referenz auf den zugeordneten Wert des vorhandenen Elements, dessen Schlüssel mit key äquivalent ist.

3) Eine Referenz auf den zugeordneten Wert des neuen Elements, wenn kein Element mit einem Schlüssel existierte, der äquivalent zum Wert x ist. Andernfalls eine Referenz auf den zugeordneten Wert des vorhandenen Elements, dessen Schlüssel äquivalent zu x ist.

Ausnahmen

Wenn eine Ausnahme durch eine Operation ausgelöst wird, hat die Einfügung keine Auswirkung.

Komplexität

Logarithmisch zur Größe des Containers.

Anmerkungen

In den veröffentlichten Standards C++11 und C++14 wurde diese Funktion so spezifiziert, dass sie mapped_type als DefaultInsertable und key_type als CopyInsertable oder MoveInsertable in *this erfordert. Diese Spezifikation war fehlerhaft und wurde durch LWG Issue 2469 behoben. Die obige Beschreibung beinhaltet die Lösung dieses Problems.

Eine Implementierung (libc++) ist jedoch dafür bekannt, die Objekte key_type und mapped_type über zwei separate Allocator-construct()-Aufrufe zu konstruieren, wie es von den veröffentlichten Standards argumentativ gefordert wird, anstatt ein value_type-Objekt emplacen.

operator[] ist nicht-const, da er den Schlüssel einfügt, wenn er nicht existiert. Wenn dieses Verhalten unerwünscht ist oder wenn der Container const ist, kann at verwendet werden.

insert_or_assign gibt mehr Informationen zurück als operator[] und erfordert keine Standardkonstruierbarkeit des zugeordneten Typs.

(seit C++17)

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_associative_heterogeneous_insertion	202311L	(C++26)	Heterogene Überladungen für die restlichen Memberfunktionen in geordneten und ungeordneten assoziativen Containern. (3)

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <map>
 
void println(auto const comment, auto const& map)
{
    std::cout << comment << '{';
    for (const auto& pair : map)
        std::cout << '{' << pair.first << ": " << pair.second << '}';
    std::cout << "}\n";
}
 
int main()
{
    std::map<char, int> letter_counts{{'a', 27}, {'b', 3}, {'c', 1}};
 
    println("letter_counts initially contains: ", letter_counts);
 
    letter_counts['b'] = 42; // updates an existing value
    letter_counts['x'] = 9;  // inserts a new value
 
    println("after modifications it contains: ", letter_counts);
 
    // count the number of occurrences of each word
    // (the first call to operator[] initialized the counter with zero)
    std::map<std::string, int>  word_map;
    for (const auto& w : {"this", "sentence", "is", "not", "a", "sentence",
                          "this", "sentence", "is", "a", "hoax"})
        ++word_map[w];
    word_map["that"]; // just inserts the pair {"that", 0}
 
    for (const auto& [word, count] : word_map)
        std::cout << count << " occurrence(s) of word '" << word << "'\n";
}

Ausgabe

letter_counts initially contains: {{a: 27}{b: 3}{c: 1}}
after modifications it contains: {{a: 27}{b: 42}{c: 1}{x: 9}}
2 occurrence(s) of word 'a'
1 occurrence(s) of word 'hoax'
2 occurrence(s) of word 'is'
1 occurrence(s) of word 'not'
3 occurrence(s) of word 'sentence'
0 occurrence(s) of word 'that'
2 occurrence(s) of word 'this'

Defect reports

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 334	C++98	der Effekt von Überladung (1) war einfach die Rückgabe von (*((insert(std::make_pair(x, T()))).first)).second	bereitstellte seine eigene Beschreibung stattdessen

Siehe auch

at	Greift mit Überprüfung auf ein bestimmtes Element zu (public member function)
insert_or_assign (C++17)	fügt ein Element ein oder weist einem vorhandenen Element einen Wert zu, falls der Schlüssel bereits existiert (public member function)
try_emplace (C++17)	fügt "in place" ein, wenn der Schlüssel nicht existiert, tut nichts, wenn der Schlüssel existiert (public member function)