Namespaces
Variants

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

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

    Sommaire

    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

    Après une construction par déplacement de conteneur (surcharge (4)), les références, pointeurs et itérateurs qui référençaient initialement les éléments dans other restent valides, mais se réfèrent aux éléments qui se trouvent maintenant dans *this. La norme actuelle fournit cette garantie par l'intermédiaire de la déclaration générale dans [container.reqmts]/67, et une garantie plus directe est à l'étude via le problème LWG 2321.

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

    Macro de test de fonctionnalitéValeur Norme Fonctionnalité
    __cpp_lib_containers_ranges 202202L (C++23) Ranges-aware construction et insertion ; 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)