Namespaces
Variants

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

From 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 ).

Inhaltsverzeichnis

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.

Hinweise

After container move construction (overload ( 11,12 ) ), references, pointers, and iterators (other than the end iterator) to other remain valid, but refer to elements that are now in * this . The current standard makes this guarantee via the blanket statement in [container.reqmts]/67 , and a more direct guarantee is under consideration via LWG-Problem 2321 .

Obwohl es erst ab C++23 formal erforderlich ist, haben einige Implementierungen den Template-Parameter Allocator bereits in früheren Modi in nicht abgeleitete Kontexte platziert.

Feature-Test Makro Wert Std Feature
__cpp_lib_containers_ranges 202202L (C++23) Ranges-basierte 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)