std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>::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::flat_map

Membertypen

Memberfunktionen

flat_map::flat_map flat_map::operator= Elementzugriff flat_map::at flat_map::operator[] Iteratoren flat_map::beginflat_map::cbegin flat_map::endflat_map::cend flat_map::rbeginflat_map::crbegin flat_map::rendflat_map::crend Suche flat_map::count flat_map::find flat_map::contains flat_map::equal_range    flat_map::lower_bound flat_map::upper_bound Kapazität flat_map::size flat_map::max_size flat_map::empty Modifizierer flat_map::clear flat_map::erase flat_map::swap flat_map::emplace flat_map::extract flat_map::replace flat_map::insert flat_map::insert_range flat_map::insert_or_assign flat_map::emplace_hint flat_map::try_emplace Observer flat_map::key_comp flat_map::keys flat_map::value_comp flat_map::values

Nicht-Member-Funktionen

operator==operator<=>         swap(std::flat_map) erase_if(std::flat_map)

Hilfsklassen

uses_allocator<std::flat_map>

Tags

sorted_unique       sorted_unique_t

Deduction Guides

 

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

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 im Aufruf konstruiert wird, falls der Schlüssel nicht existiert. Äquivalent zu return try_emplace(x).first->second;.

2) Fügt ein value_type-Objekt ein, das im Aufruf konstruiert wird, falls der Schlüssel nicht existiert. Äquivalent zu return try_emplace(std::move(x)).first->second;

3) Fügt ein value_type-Objekt ein, das im Aufruf konstruiert wird, falls kein Schlüssel existiert, der transparent äquivalent zu dem Wert x verglichen wird.

Äquivalent zu return this->try_emplace(std::forward<K>(x)).first->second;. Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der qualifizierte Name Compare::is_transparent gültig ist und einen Typ bezeichnet. Sie erlaubt den Aufruf dieser Funktion, ohne eine Instanz von Key zu konstruieren.

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, zuzüglich der Kosten für das Einfügen (falls zutreffend) eines leeren Elements.

Anmerkungen

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 als operator[] zurück und erfordert keine Default-Konstruierbarkeit des zugeordneten Typs.

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <flat_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::flat_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::flat_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'

Siehe auch

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