std::unordered_map

 

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)

 

Definiert in Header <unordered_map>
template<     class Key,     class T,     class Hash = std::hash<Key>,     class KeyEqual = std::equal_to<Key>,     class Allocator = std::allocator<std::pair<const Key, T>> > class unordered_map;	(1)	(seit C++11)
namespace pmr {     template<         class Key,         class T,         class Hash = std::hash<Key>,         class KeyEqual = std::equal_to<Key>     > using unordered_map =           std::unordered_map<Key, T, Hash, KeyEqual,               std::pmr::polymorphic_allocator<std::pair<const Key, T>>>; }	(2)	(seit C++17)

std::unordered_map ist ein assoziativer Container, der Schlüssel-Wert-Paare mit eindeutigen Schlüsseln enthält. Suchen, Einfügen und Entfernen von Elementen haben eine durchschnittliche konstante Zeitkomplexität.

Intern sind die Elemente nicht in einer bestimmten Reihenfolge sortiert, sondern in Buckets organisiert. Welcher Bucket ein Element zugewiesen wird, hängt ausschließlich vom Hash seines Schlüssels ab. Schlüssel mit demselben Hash-Code erscheinen im selben Bucket. Dies ermöglicht einen schnellen Zugriff auf einzelne Elemente, da nach der Berechnung des Hashs direkt auf den Bucket verwiesen wird, in den das Element eingefügt wurde.

Zwei Schlüssel gelten als äquivalent, wenn der Gleichheitsprädikat des Maps `true` zurückgibt, wenn diese Schlüssel übergeben werden. Wenn zwei Schlüssel äquivalent sind, muss die Hash-Funktion für beide Schlüssel denselben Wert zurückgeben.

std::unordered_map erfüllt die Anforderungen von Container, AllocatorAwareContainer, UnorderedAssociativeContainer.

Alle Memberfunktionen von std::unordered_map sind constexpr: Es ist möglich, std::unordered_map-Objekte zur Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden. Allerdings können std::unordered_map-Objekte im Allgemeinen nicht constexpr sein, da jeder dynamisch zugewiesene Speicher im selben konstanten Ausdruck freigegeben werden muss.

(seit C++26)

Iterator-Invalidierung

Operationen	Invalidiert
Alle Nur-Lese-Operationen, swap, std::swap	Niemals
clear, rehash, reserve, operator=	Immer
insert, emplace, emplace_hint, operator[]	Nur wenn eine Neubehashung verursacht wird
erase	Nur für das gelöschte Element

Anmerkungen

• Die `swap`-Funktionen machen keine der Iteratoren innerhalb des Containers ungültig, aber sie machen den Iterator, der das Ende des Swap-Bereichs markiert, ungültig.

• Referenzen und Zeiger auf Schlüssel oder Daten, die im Container gespeichert sind, werden nur durch das Löschen dieses Elements ungültig, auch wenn der entsprechende Iterator ungültig wird.

Member-Typen

Typ	Definition
key_type	Key
mapped_type	T
value_type	std::pair<const Key, T>
size_type	Vorzeichenloser Ganzzahltyp (normalerweise std::size_t)
difference_type	Vorzeichenbehafteter Ganzzahltyp (normalerweise std::ptrdiff_t)
hasher	Hash
key_equal	KeyEqual
allocator_type	Allocator
Referenz	value_type&
const_reference	const value_type&
Zeiger	std::allocator_traits<Allocator>::pointer
const_pointer	std::allocator_traits<Allocator>::const_pointer
iterator	LegacyForwardIterator und ConstexprIterator(seit C++26) zu value_type
const_iterator	LegacyForwardIterator und ConstexprIterator(seit C++26) zu const value_type
local_iterator	Ein Iterator-Typ, dessen Kategorie, Wert, Differenz, Zeiger und Referenztypen dieselben sind wie bei iterator. Dieser Iterator kann verwendet werden, um durch einen einzelnen Bucket zu iterieren, aber nicht über Buckets hinweg
const_local_iterator	Ein Iterator-Typ, dessen Kategorie, Wert, Differenz, Zeiger und Referenztypen dieselben sind wie bei const_iterator. Dieser Iterator kann verwendet werden, um durch einen einzelnen Bucket zu iterieren, aber nicht über Buckets hinweg
node_type (seit C++17)	eine Spezialisierung von node handle, die einen Containerknoten repräsentiert
insert_return_type (seit C++17)	Typ, der das Ergebnis des Einfügens eines node_type beschreibt, eine Spezialisierung von template<class Iter, class NodeType> struct /*unspecified*/ {     Iter     position;     bool     inserted;     NodeType node; }; instanziiert mit den Template-Argumenten iterator und node_type.

Memberfunktionen

(Konstruktor)	konstruiert die unordered_map (public member function)
(Destruktor)	zerstört die unordered_map (public member function)
operator=	weist dem Container Werte zu (public member function)
get_allocator	gibt den zugehörigen Allocator zurück (public member function)
Iteratoren
begincbegin	gibt einen Iterator zum Anfang zurück (public member function)
endcend	gibt einen Iterator zum Ende zurück (public member function)
Kapazität
empty	prüft, ob der Container leer ist (public member function)
size	Gibt die Anzahl der Elemente zurück (public member function)
max_size	Gibt die maximal mögliche Anzahl von Elementen zurück (public member function)
Modifizierer
clear	leert den Inhalt (public member function)
insert	fügt Elemente ein oder Knoten(seit C++17) (public member function)
insert_range (C++23)	fügt einen Bereich von Elementen ein (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)
emplace	konstruiert Elemente direkt (in-place) (public member function)
emplace_hint	konstruiert Elemente "in place" unter Verwendung eines Hinweises (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)
erase	entfernt Elemente (public member function)
swap	tauscht die Inhalte (public member function)
extract (C++17)	extrahiert Knoten aus dem Container (public member function)
merge (C++17)	fügt Knoten aus einem anderen Container zusammen (public member function)
Suche
at	Greift mit Überprüfung auf ein bestimmtes Element zu (public member function)
operator[]	greift auf ein Element zu oder fügt es ein (public member function)
zählt	gibt die Anzahl der Elemente zurück, die einem bestimmten Schlüssel entsprechen (public member function)
find	sucht ein Element mit einem bestimmten Schlüssel (public member function)
contains (C++20)	prüft, ob der Container ein Element mit einem bestimmten Schlüssel enthält (public member function)
equal_range	gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (public member function)
Bucket-Schnittstelle
begin(size_type)cbegin(size_type)	gibt einen Iterator zum Anfang des angegebenen Buckets zurück (public member function)
end(size_type)cend(size_type)	gibt einen Iterator zum Ende des angegebenen Buckets zurück (public member function)
bucket_count	gibt die Anzahl der Buckets zurück (public member function)
max_bucket_count	gibt die maximale Anzahl von Buckets zurück (public member function)
bucket_size	gibt die Anzahl der Elemente in einem bestimmten Bucket zurück (public member function)
bucket	gibt den Bucket für einen bestimmten Schlüssel zurück (public member function)
Hash-Politik
load_factor	gibt die durchschnittliche Anzahl von Elementen pro Bucket zurück (public member function)
max_load_factor	verwaltet die maximale durchschnittliche Anzahl von Elementen pro Bucket (public member function)
rehash	reserviert mindestens die angegebene Anzahl von Buckets und generiert die Hashtabelle neu (public member function)
reserve	reserviert Speicher für mindestens die angegebene Anzahl von Elementen und generiert die Hashtabelle neu (public member function)
Observer
hash_function	gibt die zum Hashen der Schlüssel verwendete Funktion zurück (public member function)
key_eq	gibt die zum Vergleichen von Schlüsseln auf Gleichheit verwendete Funktion zurück (public member function)

Nicht-Member-Funktionen

operator==operator!= (C++11)(C++11)(entfernt in C++20)	vergleicht die Werte in der unordered_map (function template)
std::swap(std::unordered_map) (C++11)	spezialisiert den Algorithmus std::swap (function template)
erase_if(std::unordered_map) (C++20)	entfernt alle Elemente, die bestimmte Kriterien erfüllen (function template)

Deduction Guides

(seit C++17)

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Bereichskonstruktion und -einfügung für Container
__cpp_lib_constexpr_containers	202502L	(C++26)	constexpr std::unordered_map

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <unordered_map>
 
int main()
{
    // Create an unordered_map of three strings (that map to strings)
    std::unordered_map<std::string, std::string> u =
    {
        {"RED", "#FF0000"},
        {"GREEN", "#00FF00"},
        {"BLUE", "#0000FF"}
    };
 
    // Helper lambda function to print key-value pairs
    auto print_key_value = [](const auto& key, const auto& value)
    {
        std::cout << "Key:[" << key << "] Value:[" << value << "]\n";
    };
 
    std::cout << "Iterate and print key-value pairs of unordered_map, being\n"
                 "explicit with their types:\n";
    for (const std::pair<const std::string, std::string>& n : u)
        print_key_value(n.first, n.second);
 
    std::cout << "\nIterate and print key-value pairs using C++17 structured binding:\n";
    for (const auto& [key, value] : u)
        print_key_value(key, value);
 
    // Add two new entries to the unordered_map
    u["BLACK"] = "#000000";
    u["WHITE"] = "#FFFFFF";
 
    std::cout << "\nOutput values by key:\n"
                 "The HEX of color RED is:[" << u["RED"] << "]\n"
                 "The HEX of color BLACK is:[" << u["BLACK"] << "]\n\n";
 
    std::cout << "Use operator[] with non-existent key to insert a new key-value pair:\n";
    print_key_value("new_key", u["new_key"]);
 
    std::cout << "\nIterate and print key-value pairs, using `auto`;\n"
                 "new_key is now one of the keys in the map:\n";
    for (const auto& n : u)
        print_key_value(n.first, n.second);
}

Mögliche Ausgabe

Iterate and print key-value pairs of unordered_map, being
explicit with their types:
Key:[BLUE] Value:[#0000FF]
Key:[GREEN] Value:[#00FF00]
Key:[RED] Value:[#FF0000]
 
Iterate and print key-value pairs using C++17 structured binding:
Key:[BLUE] Value:[#0000FF]
Key:[GREEN] Value:[#00FF00]
Key:[RED] Value:[#FF0000]
 
Output values by key:
The HEX of color RED is:[#FF0000]
The HEX of color BLACK is:[#000000]
 
Use operator[] with non-existent key to insert a new key-value pair:
Key:[new_key] Value:[]
 
Iterate and print key-value pairs, using `auto`;
new_key is now one of the keys in the map:
Key:[new_key] Value:[]
Key:[WHITE] Value:[#FFFFFF]
Key:[BLACK] Value:[#000000]
Key:[BLUE] Value:[#0000FF]
Key:[GREEN] Value:[#00FF00]
Key:[RED] Value:[#FF0000]

Fehlerberichte

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 2050	C++11	die Definitionen von reference, const_reference, pointer und const_pointer basierten auf allocator_type	basierend auf value_type und std::allocator_traits

Siehe auch

unordered_multimap (C++11)	Sammlung von Schlüssel-Wert-Paaren, gehasht nach Schlüsseln (Klassenvorlage)
map	Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln, Schlüssel sind eindeutig (Klassenvorlage)
flat_map (C++23)	passt zwei Container an, um eine Sammlung von Schlüssel-Wert-Paaren, sortiert nach eindeutigen Schlüsseln, bereitzustellen (Klassenvorlage)