std::unordered_map<Key,T,Hash,KeyEqual,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::unordered_map

Membertypen
Memberfunktionen
unordered_map::unordered_map unordered_map::~unordered_map unordered_map::operator= unordered_map::get_allocator Iteratoren unordered_map::beginunordered_map::cbegin unordered_map::endunordered_map::cend Kapazität unordered_map::size unordered_map::max_size unordered_map::empty Modifizierer unordered_map::clear unordered_map::erase unordered_map::swap unordered_map::extract (C++17) unordered_map::merge (C++17) unordered_map::insert unordered_map::insert_range (C++23) unordered_map::insert_or_assign (C++17)   unordered_map::emplace unordered_map::emplace_hint unordered_map::try_emplace (C++17)	Suche unordered_map::at unordered_map::operator[] unordered_map::count unordered_map::find unordered_map::contains (C++20) unordered_map::equal_range Bucket-Schnittstelle unordered_map::begin(size_type)unordered_map::cbegin(size_type) unordered_map::end(size_type)unordered_map::cend(size_type) unordered_map::bucket_count unordered_map::max_bucket_count unordered_map::bucket_size unordered_map::bucket Hash-Politik unordered_map::load_factor unordered_map::max_load_factor unordered_map::rehash unordered_map::reserve Observer unordered_map::hash_function unordered_map::key_eq
Nicht-Member-Funktionen
operator==operator!= (bis C++20)	std::swap(std::unordered_map) erase_if(std::unordered_map) (C++20)
Abzugsführer(C++17)

 

T& operator[]( const Key& key );	(1)	(seit C++11)
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-Objekt ein, das aus std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() erstellt wird, falls der Schlüssel nicht existiert.

Entspricht return this->try_emplace(key).first->second;.(seit C++17)Wenn der Standard-Allocator verwendet wird, wird der Schlüssel aus key kopierkonstruiert und der zugeordnete Wert wertinitialisiert.

- value_type muss von std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>() EmplaceConstructible sein. Wenn der Standard-Allocator verwendet wird, 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<>() erstellt wird, falls der Schlüssel nicht existiert.

Entspricht return this->try_emplace(std::move(key)).first->second;.(seit C++17)
Wenn der Standard-Allocator verwendet wird, wird der Schlüssel aus key move-konstruiert und der zugeordnete Wert wertinitialisiert.

- value_type muss von std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::tuple<>() EmplaceConstructible sein. Wenn der Standard-Allocator verwendet wird, bedeutet dies, dass key_type MoveConstructible und mapped_type DefaultConstructible sein muss.

3) Fügt ein value_type-Objekt ein, falls kein Schlüssel existiert, der transparent mit dem Wert x verglichen werden kann.

Entspricht return this->try_emplace(std::forward<K>(x)).first->second;. Diese Überladung nimmt nur an der Auflösung von Überladungen teil, wenn Hash::is_transparent und KeyEqual::is_transparent gültig sind und jeweils einen Typ bezeichnen. Dies setzt voraus, dass ein solches Hash mit Typen K und Key aufrufbar ist und dass KeyEqual transparent ist, was zusammen das Aufrufen dieser Funktion ermöglicht, ohne eine Instanz von Key zu konstruieren.

Wenn nach der Operation die neue Anzahl der Elemente größer ist als max_load_factor() * bucket_count(), findet ein Rehashing statt.
Wenn Rehashing stattfindet (aufgrund der Einfügung), werden alle Iteratoren ungültig. Andernfalls (kein Rehashing) werden Iteratoren nicht 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

Durchschnittlicher Fall: konstant, schlimmster Fall: linear zur Größe.

Anmerkungen

In den veröffentlichten Standards C++11 und C++14 war für diese Funktion vorgeschrieben, dass mapped_type DefaultInsertable und key_type CopyInsertable oder MoveInsertable in *this sein musste. Diese Spezifikation war fehlerhaft und wurde durch LWG Issue 2469 behoben, und die obige Beschreibung enthält die Lösung dieses Problems.

Eine Implementierung (libc++) ist jedoch dafür bekannt, die Objekte vom Typ key_type und mapped_type über zwei separate construct()-Aufrufe des Allocators zu erstellen, wie es nach den veröffentlichten Standards argumentativ erforderlich war, anstatt ein value_type-Objekt zu emplacen.

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

insert_or_assign gibt mehr Informationen zurück als operator[] und erfordert keine Default-Konstruierbarkeit 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 verbleibenden Member-Funktionen in geordneten und ungeordneten assoziativen Containern. (3)

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <unordered_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::unordered_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::unordered_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";
}

Mögliche 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'

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)