Namespaces
Variants

std:: unordered_map

From cppreference.net
C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
Definiert im 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. Suche, Einfügung und Entfernung von Elementen haben durchschnittlich konstante Zeitkomplexität.

Internally werden die Elemente nicht in einer bestimmten Reihenfolge sortiert, sondern in Buckets organisiert. In welchen Bucket ein Element platziert wird, hängt vollständig vom Hash seines Schlüssels ab. Schlüssel mit demselben Hashcode erscheinen im selben Bucket. Dies ermöglicht einen schnellen Zugriff auf einzelne Elemente, da sobald der Hash berechnet ist, dieser auf den Bucket verweist, der das Element enthält.

Zwei Schlüssel werden als äquivalent betrachtet, wenn das Schlüsselgleichheitsprädikat der Map bei Übergabe dieser Schlüssel true zurückgibt. 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 in der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden.

Allerdings können std::unordered_map -Objekte im Allgemeinen nicht constexpr sein, da jeder dynamisch allokierte Speicher in derselben Auswertung des konstanten Ausdrucks freigegeben werden muss.

(since C++26)

Inhaltsverzeichnis

Iterator-Invalidierung

Operationen Ungültig gemacht
Alle schreibgeschützten Operationen, swap , std::swap Niemals
clear , rehash , reserve , operator= Immer
insert , emplace , emplace_hint , operator[] Nur bei Rehash-Auslösung
erase Nur für das gelöschte Element

Hinweise

  • Die Swap-Funktionen machen keine Iteratoren innerhalb des Containers ungültig, aber sie machen den Iterator ungültig, der das Ende der Swap-Region markiert.
  • Referenzen und Zeiger auf entweder Schlüssel oder Daten, die im Container gespeichert sind, werden nur durch das Löschen dieses Elements ungültig, selbst wenn der entsprechende Iterator ungültig wird.

Template-Parameter

Dieser Abschnitt ist unvollständig
Grund: Beschreibungen der Template-Parameter hinzufügen.

Mitgliedertypen

Typ Definition
key_type Key
mapped_type T
value_type std:: pair < const Key, T >
size_type Vorzeichenloser Ganzzahltyp (üblicherweise std::size_t )
difference_type Vorzeichenbehafteter Ganzzahltyp (üblicherweise std::ptrdiff_t )
hasher Hash
key_equal KeyEqual
allocator_type Allocator
reference value_type &
const_reference const value_type &
pointer 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 Iteratortyp, dessen Kategorie, Wert-, Differenz-, Zeiger- und
Referenztypen mit iterator übereinstimmen. Dieser Iterator
kann verwendet werden, um durch einen einzelnen Bucket zu iterieren, aber nicht über Buckets hinweg
const_local_iterator Ein Iteratortyp, dessen Kategorie, Wert-, Differenz-, Zeiger- und
Referenztypen mit const_iterator übereinstimmen. 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 Container-Knoten darstellt
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 /*unspezifiziert*/
{
Iter     position ;
bool inserted ;
NodeType node ;
} ;
instanziiert mit den Template-Argumenten iterator und node_type .

Memberfunktionen

Konstruiert die unordered_map
(öffentliche Elementfunktion)
zerstört die unordered_map
(öffentliche Elementfunktion)
weist dem Container Werte zu
(öffentliche Elementfunktion)
gibt den zugeordneten Allokator zurück
(öffentliche Elementfunktion)
Iteratoren
gibt einen Iterator zum Anfang zurück
(public member function)
gibt einen Iterator zum Ende zurück
(öffentliche Elementfunktion)
Kapazität
prüft, ob der Container leer ist
(öffentliche Elementfunktion)
gibt die Anzahl der Elemente zurück
(public member function)
gibt die maximal mögliche Anzahl von Elementen zurück
(öffentliche Elementfunktion)
Modifikatoren
löscht den Inhalt
(öffentliche Elementfunktion)
fügt Elemente ein oder Knoten (seit C++17)
(öffentliche Elementfunktion)
(C++23)
fügt eine Reihe von Elementen ein
(öffentliche Elementfunktion)
(C++17)
Fügt ein Element ein oder weist es zu, wenn der Schlüssel bereits existiert
(öffentliche Member-Funktion)
Konstruiert Elemente direkt
(öffentliche Elementfunktion)
Konstruiert Elemente direkt unter Verwendung eines Hinweises
(öffentliche Elementfunktion)
(C++17)
Fügt ein Element direkt ein, falls der Schlüssel nicht existiert, tut nichts, falls der Schlüssel existiert
(öffentliche Elementfunktion)
löscht Elemente
(öffentliche Elementfunktion)
tauscht die Inhalte aus
(öffentliche Elementfunktion)
(C++17)
extrahiert Knoten aus dem Container
(öffentliche Elementfunktion)
(C++17)
verbindet Knoten aus einem anderen Container
(öffentliche Elementfunktion)
Lookup
Zugriff auf bestimmtes Element mit Grenzprüfung
(öffentliche Member-Funktion)
greift auf ein bestimmtes Element zu oder fügt es ein
(öffentliche Elementfunktion)
gibt die Anzahl der Elemente zurück, die einem bestimmten Schlüssel entsprechen
(public member function)
findet Element mit spezifischem Schlüssel
(public member function)
(C++20)
prüft, ob der Container ein Element mit spezifischem Schlüssel enthält
(öffentliche Elementfunktion)
Gibt den Bereich der Elemente zurück, die einem bestimmten Schlüssel entsprechen
(öffentliche Elementfunktion)
Bucket-Schnittstelle
gibt einen Iterator zum Anfang des angegebenen Buckets zurück
(öffentliche Member-Funktion)
gibt einen Iterator zum Ende des angegebenen Buckets zurück
(öffentliche Elementfunktion)
gibt die Anzahl der Buckets zurück
(öffentliche Elementfunktion)
gibt die maximale Anzahl von Buckets zurück
(öffentliche Elementfunktion)
gibt die Anzahl der Elemente in einem bestimmten Bucket zurück
(öffentliche Elementfunktion)
gibt den Bucket für einen bestimmten Schlüssel zurück
(öffentliche Elementfunktion)
Hash-Policy
Gibt die durchschnittliche Anzahl von Elementen pro Bucket zurück
(öffentliche Mitgliedsfunktion)
verwaltet die maximale durchschnittliche Anzahl von Elementen pro Bucket
(öffentliche Elementfunktion)
reserviert mindestens die angegebene Anzahl von Buckets und regeneriert die Hashtabelle
(öffentliche Elementfunktion)
reserviert Platz für mindestens die angegebene Anzahl von Elementen und regeneriert die Hashtabelle
(öffentliche Elementfunktion)
Beobachter
Gibt die Funktion zurück, die zum Hashen der Schlüssel verwendet wird
(öffentliche Elementfunktion)
gibt die Funktion zurück, die zum Vergleichen von Schlüsseln auf Gleichheit verwendet wird
(öffentliche Elementfunktion)

Nicht-Member-Funktionen

(C++11) (C++11) (entfernt in C++20)
vergleicht die Werte in der unordered_map
(Funktions-Template)
(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(C++20)
löscht alle Elemente, die bestimmte Kriterien erfüllen
(Funktions-Template)

Deduktionsleitfäden

(seit C++17)

Hinweise

Feature-Test Makro Wert Std Funktion
__cpp_lib_containers_ranges 202202L (C++23) Ranges-Konstruktion und -Einfügung für Container
__cpp_lib_constexpr_unordered_map 202502L (C++26) constexpr std::unordered_map

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <string>
#include <unordered_map>
int main()
{
    // Erstelle eine unordered_map von drei Strings (die auf Strings abbilden)
    std::unordered_map<std::string, std::string> u =
    {
        {"RED", "#FF0000"},
        {"GREEN", "#00FF00"},
        {"BLUE", "#0000FF"}
    };
    // Hilfs-Lambda-Funktion zum Ausgeben von Schlüssel-Wert-Paaren
    auto print_key_value = [](const auto& key, const auto& value)
    {
        std::cout << "Key:[" << key << "] Value:[" << value << "]\n";
    };
    std::cout << "Iteriere und gebe Schlüssel-Wert-Paare der unordered_map aus, wobei\n"
                 "explizit mit ihren Typen gearbeitet wird:\n";
    for (const std::pair<const std::string, std::string>& n : u)
        print_key_value(n.first, n.second);
    std::cout << "\nIteriere und gebe Schlüssel-Wert-Paare mit C++17 Structured Binding aus:\n";
    for (const auto& [key, value] : u)
        print_key_value(key, value);
    // Füge zwei neue Einträge zur unordered_map hinzu
    u["BLACK"] = "#000000";
    u["WHITE"] = "#FFFFFF";
    std::cout << "\nGebe Werte nach Schlüssel aus:\n"
                 "Der HEX-Wert der Farbe ROT ist:[" << u["RED"] << "]\n"
                 "Der HEX-Wert der Farbe SCHWARZ ist:[" << u["BLACK"] << "]\n\n";
    std::cout << "Verwende operator[] mit nicht-existierendem Schlüssel zum Einfügen eines neuen Schlüssel-Wert-Paares:\n";
    print_key_value("new_key", u["new_key"]);
    std::cout << "\nIteriere und gebe Schlüssel-Wert-Paare mit `auto` aus;\n"
                 "new_key ist nun einer der Schlüssel in der Map:\n";
    for (const auto& n : u)
        print_key_value(n.first, n.second);
}

Mögliche Ausgabe: 

Iteriere und gebe Schlüssel-Wert-Paare der unordered_map aus, wobei
explizit mit ihren Typen gearbeitet wird:
Key:[BLUE] Value:[#0000FF]
Key:[GREEN] Value:[#00FF00]
Key:[RED] Value:[#FF0000]
Iteriere und gebe Schlüssel-Wert-Paare mit C++17 Structured Binding aus:
Key:[BLUE] Value:[#0000FF]
Key:[GREEN] Value:[#00FF00]
Key:[RED] Value:[#FF0000]
Gebe Werte nach Schlüssel aus:
Der HEX-Wert der Farbe ROT ist:[#FF0000]
Der HEX-Wert der Farbe SCHWARZ ist:[#000000]
Verwende operator[] mit nicht-existierendem Schlüssel zum Einfügen eines neuen Schlüssel-Wert-Paares:
Key:[new_key] Value:[]
Iteriere und gebe Schlüssel-Wert-Paare mit `auto` aus;
new_key ist nun einer der Schlüssel in der 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 		basieren auf value_type und
std::allocator_traits

Siehe auch

(C++11)
Sammlung von Schlüssel-Wert-Paaren, gehasht nach Schlüsseln
(Klassen-Template)
Sammlung von Schlüssel-Wert-Paaren, sortiert nach Schlüsseln, Schlüssel sind eindeutig
(Klassen-Template)
(C++23)
passt zwei Container an, um eine Sammlung von Schlüssel-Wert-Paaren zu bieten, sortiert nach eindeutigen Schlüsseln
(Klassen-Template)