Namespaces
Variants

    std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: unordered_map

    From de.cppreference.net

    C++
    Containers library
    std::unordered_map
    Member types
    Member functions
    Non-member functions
    Deduction guides (C++17)
    **Änderungen:** - "(since C++11)" wurde zu "(seit C++11)" übersetzt - Alle HTML-Tags, Attribute und Code-Elemente wurden unverändert beibehalten - C++-spezifische Begriffe wie `explicit`, `unordered_map`, `size_type`, `Hash`, `key_equal`, `Allocator` wurden nicht übersetzt - Die Formatierung und Struktur des HTML-Codes wurde vollständig erhalten
    (1)
    unordered_map ( )
    : unordered_map ( size_type ( /* unspecified */ ) ) { }
    		(seit C++11)
    (bis C++20)
    unordered_map ( ) ;
    		(seit C++20)
    explicit unordered_map ( size_type bucket_count,

    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(2) (seit C++11)
    unordered_map ( size_type bucket_count,

    const Allocator & alloc )

    : unordered_map ( bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
    		(3) (seit C++14)
    unordered_map ( size_type bucket_count,

    const Hash & hash,
    const Allocator & alloc )

    : unordered_map ( bucket_count, hash, key_equal ( ) , alloc ) { }
    		(4) (seit C++14)
    explicit unordered_map ( const Allocator & alloc ) ;
    		(5) (seit C++11)
    template < class InputIt >

    unordered_map ( InputIt first, InputIt last,
    size_type bucket_count = /* nicht spezifiziert */ ,
    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(6) (seit C++11)
    template < class InputIt >

    unordered_map ( InputIt first, InputIt last,
    size_type bucket_count,
    const Allocator & alloc )
    : unordered_map ( first, last,

    bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
    		(7) (seit C++14)
    template < class InputIt >

    unordered_map ( InputIt first, InputIt last,
    size_type bucket_count,
    const Hash & hash,
    const Allocator & alloc )
    : unordered_map ( first, last,

    bucket_count, hash, key_equal ( ) , alloc ) { }
    		(8) (seit C++14)
    unordered_map ( const unordered_map & other ) ;
    		(9) (seit C++11)
    unordered_map ( const unordered_map & other, const Allocator & alloc ) ;
    		(10) (seit C++11)
    unordered_map ( unordered_map && other ) ;
    		(11) (seit C++11)
    unordered_map ( unordered_map && other, const Allocator & alloc ) ;
    		(12) (seit C++11)
    unordered_map ( std:: initializer_list < value_type > init,

    size_type bucket_count = /* nicht spezifiziert */ ,
    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(13) (seit C++11)
    unordered_map ( std:: initializer_list < value_type > init,

    size_type bucket_count,
    const Allocator & alloc )
    : unordered_map ( init, bucket_count,

    Hash ( ) , key_equal ( ) , alloc ) { }
    		(14) (seit C++14)
    unordered_map ( std:: initializer_list < value_type > init,

    size_type bucket_count,
    const Hash & hash,
    const Allocator & alloc )
    : unordered_map ( init, bucket_count,

    hash, key_equal ( ) , alloc ) { }
    		(15) (seit C++14)
    template < container-compatible-range < value_type > R >

    unordered_map ( std:: from_range_t , R && rg,
    size_type bucket_count = /* siehe Beschreibung */ ,
    const Hash & hash = Hash ( ) ,
    const key_equal & equal = key_equal ( ) ,

    const Allocator & alloc = Allocator ( ) ) ;
    		(16) (seit C++23)
    template < container-compatible-range < value_type > R >

    unordered_map ( std:: from_range_t , R && rg,
    size_type bucket_count,
    const Allocator & alloc )
    : unordered_map ( std:: from_range , std:: forward < R > ( rg ) ,

    bucket_count, Hash ( ) , key_equal ( ) , alloc ) { }
    		(17) (seit C++23)
    template < container-compatible-range < value_type > R >

    unordered_map ( std:: from_range_t , R && rg,
    size_type bucket_count,
    const Hash & hash,
    const Alloc & alloc )
    : unordered_map ( std:: from_range , std:: forward < R > ( rg ) ,

    bucket_count, hash, key_equal ( ) , alloc ) { }
    		(18) (seit C++23)

    Konstruiert einen neuen Container aus verschiedenen Datenquellen. Verwendet optional die vom Benutzer bereitgestellte bucket_count als minimale Anzahl zu erstellender Buckets, hash als Hash-Funktion, equal als Funktion zum Vergleichen von Schlüsseln und alloc als Allokator.

    1-5) Konstruiert einen leeren Container. Setzt max_load_factor() auf 1.0 . Für den Standardkonstruktor ist die Anzahl der Buckets nicht spezifiziert.
    6-8) Konstruiert den Container mit den Inhalten des Bereichs [ first , last ) . Setzt max_load_factor() auf 1.0 . Falls mehrere Elemente im Bereich Schlüssel haben, die äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (ausstehend LWG2844 ).
    9,10) Kopierkonstruktor. Konstruiert den Container mit der Kopie der Inhalte von other , kopiert ebenfalls den Ladefaktor, das Prädikat und die Hash-Funktion. Falls alloc nicht bereitgestellt wird, wird der Allokator durch Aufruf von std:: allocator_traits < allocator_type > :: select_on_container_copy_construction ( other. get_allocator ( ) ) erhalten.

    Der Template-Parameter Allocator wird nur vom ersten Argument abgeleitet, wenn Klassentemplate-Argumentableitung verwendet wird.

    		(seit C++23)
    11,12) Move-Konstruktor . Konstruiert den Container mit den Inhalten von other unter Verwendung von Move-Semantik. Wenn alloc nicht bereitgestellt wird, wird der Allokator durch Move-Konstruktion vom Allokator von other erhalten.

    Der Template-Parameter Allocator wird nur vom ersten Argument abgeleitet, wenn er in Class Template Argument Deduction verwendet wird.

    		(seit C++23)
    13-15) Initializer-list-Konstruktor . Konstruiert den Container mit den Inhalten der Initialisierungsliste init , identisch mit unordered_map ( init. begin ( ) , init. end ( ) ) .
    16-18) Konstruiert den Container mit den Inhalten von rg . Falls mehrere Elemente im Bereich Schlüssel haben, die äquivalent verglichen werden, ist nicht spezifiziert, welches Element eingefügt wird (ausstehend LWG2844 ).

    Inhalt

    Parameter

    alloc - Allokator, der für alle Speicherallokationen dieses Containers verwendet wird
    bucket_count - Minimale Anzahl der Buckets, die bei der Initialisierung verwendet werden. Wenn nicht angegeben, wird ein nicht spezifizierter Standardwert verwendet
    hash - Zu verwendende Hash-Funktion
    equal - Vergleichsfunktion, die für alle Schlüsselvergleiche dieses Containers verwendet wird
    first, last - Das Iteratorpaar, das die Quelle des Bereichs der zu kopierenden Elemente definiert
    rg - Ein container-kompatibler Bereich , also ein input_range , dessen Elemente in value_type konvertierbar sind
    other - Ein weiterer Container, der als Quelle zur Initialisierung der Elemente des Containers verwendet wird
    init - Initialisierungsliste zur Initialisierung der Elemente des Containers
    Typanforderungen
    -
    InputIt muss die Anforderungen von LegacyInputIterator erfüllen.

    Komplexität

    1-5) Konstante.
    6-8) Durchschnittliche Laufzeit linear (d.h. O(N) , wobei N gleich std:: distance ( first, last ) ist), im schlimmsten Fall quadratisch, d.h. O(N 2 ) .
    9,10) Linear in der Größe von other .
    11,12) Konstant. Wenn alloc angegeben ist und alloc ! = other. get_allocator ( ) , dann linear.
    13-15) Durchschnittlicher Fall O(N) ( N ist std:: size ( init ) ), schlechtester Fall O(N 2 ) .
    16-18) Durchschnittlicher Fall O(N) ( N ist ranges:: distance ( rg ) ), schlimmster Fall O(N 2 ) .

    Ausnahmen

    Aufrufe von Allocator::allocate können eine Ausnahme auslösen.

    Anmerkungen

    Nach der Verschiebungskonstruktion eines Containers (Überladung (4)), bleiben Referenzen, Zeiger und Iteratoren, die ursprünglich auf Elemente in other verwiesen haben, gültig, beziehen sich aber auf Elemente, die sich jetzt in *this befinden. Der aktuelle Standard gewährleistet dies durch die allgemeine Aussage in [container.reqmts]/67, und eine direktere Garantie wird via LWG issue 2321 in Betracht gezogen.

    Obwohl erst ab C++23 formal erforderlich, haben einige Implementierungen den Vorlagenparameter Allocator bereits in früheren Modi in nicht-deduzierte Kontexte gesetzt.

    Feature-TestMakro Wert Standard Feature
    __cpp_lib_containers_ranges 202202L (C++23) Ranges-bewusste Konstruktion und Einfügung; Überladungen (16-18)

    Beispiel

    Diesen Code ausführen 
    #include <bitset>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
struct Key
{
    std::string first;
    std::string second;
};
struct KeyHash
{
    std::size_t operator()(const Key& k) const
    {
        return std::hash<std::string>()(k.first) ^
            (std::hash<std::string>()(k.second) << 1);
    }
};
struct KeyEqual
{
    bool operator()(const Key& lhs, const Key& rhs) const
    {
        return lhs.first == rhs.first && lhs.second == rhs.second;
    }
};
struct Foo
{
    Foo(int val_) : val(val_) {}
    int val;
    bool operator==(const Foo &rhs) const { return val == rhs.val; }
};
template<>
struct std::hash<Foo>
{
    std::size_t operator()(const Foo &f) const
    {
        return std::hash<int>{}(f.val);
    }
};
int main()
{
    // Standardkonstruktor: leere Map
    std::unordered_map<std::string, std::string> m1;
    // Listenkonstruktor
    std::unordered_map<int, std::string> m2 =
    {
        {1, "foo"},
        {3, "bar"},
        {2, "baz"}
    };
    // Kopierkonstruktor
    std::unordered_map<int, std::string> m3 = m2;
    // Move-Konstruktor
    std::unordered_map<int, std::string> m4 = std::move(m2);
    // Bereichskonstruktor
    std::vector<std::pair<std::bitset<8>, int>> v = {{0x12, 1}, {0x01,-1}};
    std::unordered_map<std::bitset<8>, double> m5(v.begin(), v.end());
    // Option 1 für einen Konstruktor mit einem benutzerdefinierten Schlüsseltyp
    // Definieren Sie die KeyHash- und KeyEqual-Strukturen und verwenden Sie sie in der Vorlage
    std::unordered_map<Key, std::string, KeyHash, KeyEqual> m6 =
    {
        {{"John", "Doe"}, "Beispiel"},
        {{"Mary", "Sue"}, "another"}
    };
    // Option 2 für einen Konstruktor mit einem benutzerdefinierten Schlüsseltyp.
    // Definiere einen const == Operator für die Klasse/Struktur und spezialisiere std::hash
    // Struktur im std-Namespace
    std::unordered_map<Foo, std::string> m7 =
    {
        {Foo(1), "Eins"}, {2, "Zwei"}, {3, "Drei"}
    };
    // Option 3: Lambdas verwenden
    // Beachten Sie, dass die anfängliche Bucket-Anzahl an den Konstruktor übergeben werden muss
    struct Goo { int val; };
    auto hash = [](const Goo &g){ return std::hash<int>{}(g.val); };
    auto comp = [](const Goo &l, const Goo &r){ return l.val == r.val; };
    std::unordered_map<Goo, double, decltype(hash), decltype(comp)> m8(10, hash, comp);
}

    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 2193 C++11 der Standardkonstruktor ( 1 ) war explicit als non-explicit festgelegt
    LWG 2230 C++11 die Semantik von Überladung ( 13 ) war nicht spezifiziert spezifiziert

    Siehe auch

    		weist dem Container Werte zu
    (öffentliche Elementfunktion)