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)
(1)
unordered_map ( )
: unordered_map ( size_type ( /* unspecified */ ) ) { }
(depuis C++11)
(jusqu'à C++20)
unordered_map ( ) ;
(depuis C++20)
explicit unordered_map ( size_type bucket_count,

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

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

const Allocator & alloc )

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

const Hash & hash,
const Allocator & alloc )

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

unordered_map ( InputIt first, InputIt last,
size_type bucket_count = /* non spécifié */ ,
const Hash & hash = Hash ( ) ,
const key_equal & equal = key_equal ( ) ,

const Allocator & alloc = Allocator ( ) ) ;
(6) (depuis 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) (depuis 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) (depuis C++14)
unordered_map ( const unordered_map & other ) ;
(9) (depuis C++11)
unordered_map ( const unordered_map & other, const Allocator & alloc ) ;
(10) (depuis C++11)
unordered_map ( unordered_map && other ) ;
(11) (depuis C++11)
unordered_map ( unordered_map && other, const Allocator & alloc ) ;
(12) (depuis C++11)
unordered_map ( std:: initializer_list < value_type > init,

size_type bucket_count = /* non spécifié */ ,
const Hash & hash = Hash ( ) ,
const key_equal & equal = key_equal ( ) ,

const Allocator & alloc = Allocator ( ) ) ;
(13) (depuis 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) (depuis 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) (depuis C++14)
template < container-compatible-range < value_type > R >

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

const Allocator & alloc = Allocator ( ) ) ;
(16) (depuis 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) (depuis 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) (depuis C++23)

Construit un nouveau conteneur à partir de diverses sources de données. Utilise optionnellement le bucket_count fourni par l'utilisateur comme nombre minimal de compartiments à créer, hash comme fonction de hachage, equal comme fonction de comparaison des clés et alloc comme allocateur.

1-5) Construit un conteneur vide. Définit max_load_factor() à 1.0 . Pour le constructeur par défaut, le nombre de compartiments n'est pas spécifié.
6-8) Construit le conteneur avec le contenu de la plage [ first , last ) . Définit max_load_factor() à 1.0 . Si plusieurs éléments dans la plage ont des clés qui sont équivalentes, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).
9,10) Constructeur de copie. Construit le conteneur avec la copie du contenu de other , copie également le facteur de charge, le prédicat et la fonction de hachage. Si alloc n'est pas fourni, l'allocateur est obtenu en appelant std:: allocator_traits < allocator_type > :: select_on_container_copy_construction ( other. get_allocator ( ) ) .

Le paramètre template Allocator est uniquement déduit du premier argument lorsqu'il est utilisé dans la déduction d'arguments de template de classe .

(depuis C++23)
11,12) Constructeur de déplacement . Construit le conteneur avec le contenu de other en utilisant la sémantique de déplacement. Si alloc n'est pas fourni, l'allocateur est obtenu par construction par déplacement depuis l'allocateur appartenant à other .

Le paramètre template Allocator est seulement déduit du premier argument lorsqu'il est utilisé dans la déduction d'arguments de template de classe .

(depuis C++23)
13-15) Constructeur de liste d'initialisation . Construit le conteneur avec le contenu de la liste d'initialisation init , identique à unordered_map ( init. begin ( ) , init. end ( ) ) .
16-18) Construit le conteneur avec le contenu de rg . Si plusieurs éléments dans la plage ont des clés qui sont équivalentes, il n'est pas spécifié quel élément est inséré (en attente de LWG2844 ).

Table des matières

Paramètres

alloc - allocateur à utiliser pour toutes les allocations mémoire de ce conteneur
bucket_count - nombre minimal de compartiments à utiliser lors de l'initialisation. S'il n'est pas spécifié, une valeur par défaut non spécifiée est utilisée
hash - fonction de hachage à utiliser
equal - fonction de comparaison à utiliser pour toutes les comparaisons de clés de ce conteneur
first, last - la paire d'itérateurs définissant la plage source des éléments à copier
rg - une plage compatible avec le conteneur , c'est-à-dire une input_range dont les éléments sont convertibles en value_type
other - un autre conteneur à utiliser comme source pour initialiser les éléments du conteneur
init - liste d'initialisation pour initialiser les éléments du conteneur
Exigences de type
-
InputIt doit satisfaire aux exigences de LegacyInputIterator .

Complexité

1-5) Constant.
6-8) Cas moyen linéaire (c'est-à-dire O(N) , où N est std:: distance ( first, last ) ), cas pire quadratique, c'est-à-dire O(N 2 ) .
9,10) Linéaire en fonction de la taille de other .
11,12) Constant. Si alloc est fourni et alloc ! = other. get_allocator ( ) , alors linéaire.
13-15) Cas moyen O(N) ( N est std:: size ( init ) ), cas le pire O(N 2 ) .
16-18) Cas moyen O(N) ( N est ranges:: distance ( rg ) ), cas le pire O(N 2 ) .

Exceptions

Les appels à Allocator::allocate peuvent lever une exception.

Notes

After container move construction (overload ( 11,12 ) ), references, pointers, and iterators (other than the end iterator) to autre 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 Problème LWG 2321 .

Bien que non formellement requis avant C++23, certaines implémentations ont déjà placé le paramètre template Allocator dans des contextes non déduits dans les modes antérieurs.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion compatibles avec les gammes ; surcharges ( 16-18 )

Exemple

Exécuter ce code 
#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.premier) ^
            (std::hash<std::string>()(k.second) << 1);
    }
};
struct KeyEqual
{
    bool operator()(const Key& lhs, const Key& rhs) const
    {
        return lhs.premier == rhs.premier && 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()
{
    // constructeur par défaut : map vide
    std::unordered_map<std::string, std::string> m1;
    // constructeur de liste
    std::unordered_map<int, std::string> m2 =
    {
        {1, "foo"},
        {3, "bar"},
        {2, "baz"}
    };
    // constructeur de copie
    std::unordered_map<int, std::string> m3 = m2;
    // constructeur de déplacement
    std::unordered_map<int, std::string> m4 = std::move(m2);
    // constructeur de plage
    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 pour un constructeur avec un type Key personnalisé
    // Définir les structs KeyHash et KeyEqual et les utiliser dans le template
    std::unordered_map<Key, std::string, KeyHash, KeyEqual> m6 =
    {
        {{"John", "Doe"}, "exemple"},
        {{"Mary", "Sue"}, "autre"}
    };
    // Option 2 pour un constructeur avec un type Key personnalisé.
    // Définir un opérateur == const pour la classe/structure et spécialiser std::hash
    // structure dans l'espace de noms std
    std::unordered_map<Foo, std::string> m7 =
    {
        {Foo(1), "Un"}, {2, "Deux"}, {3, "Trois"}
    };
    // Option 3: Utiliser des lambdas
    // Notez que le nombre initial de compartiments doit être passé au constructeur
    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);
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR S'applique à Comportement publié Comportement corrigé
LWG 2193 C++11 le constructeur par défaut ( 1 ) était explicite rendu non-explicite
LWG 2230 C++11 la sémantique de la surcharge ( 13 ) n'était pas spécifiée spécifiée

Voir aussi

assigne des valeurs au conteneur
(fonction membre publique)