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)
Défini dans l'en-tête <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) (depuis 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) (depuis C++17)

std::unordered_map est un conteneur associatif qui contient des paires clé-valeur avec des clés uniques. La recherche, l'insertion et la suppression d'éléments ont une complexité temporelle moyenne constante.

En interne, les éléments ne sont pas triés dans un ordre particulier, mais organisés en compartiments. Le compartiment dans lequel un élément est placé dépend entièrement du hachage de sa clé. Les clés avec le même code de hachage apparaissent dans le même compartiment. Cela permet un accès rapide aux éléments individuels, car une fois le hachage calculé, il fait référence au compartiment contenant l'élément.

Deux clés sont considérées comme équivalentes si le prédicat d'égalité des clés de la carte renvoie vrai lorsqu'il reçoit ces clés. Si deux clés sont équivalentes, la fonction de hachage doit renvoyer la même valeur pour les deux clés.

std::unordered_map satisfait aux exigences de Container , AllocatorAwareContainer , UnorderedAssociativeContainer .

Toutes les fonctions membres de std::unordered_map sont constexpr : il est possible de créer et d'utiliser des objets std::unordered_map lors de l'évaluation d'une expression constante.

Cependant, les objets std::unordered_map ne peuvent généralement pas être constexpr , car toute mémoire allouée dynamiquement doit être libérée lors de la même évaluation d'expression constante.

(depuis C++26)

Table des matières

Invalidation des itérateurs

Opérations Invalidations
Toutes les opérations en lecture seule, swap , std::swap Jamais
clear , rehash , reserve , operator= Toujours
insert , emplace , emplace_hint , operator[] Seulement si provoque un rehash
erase Uniquement pour l'élément effacé

Notes

  • Les fonctions d'échange n'invalident aucun des itérateurs à l'intérieur du conteneur, mais elles invalident l'itérateur marquant la fin de la région d'échange.
  • Les références et les pointeurs vers la clé ou les données stockées dans le conteneur ne sont invalidés que par l'effacement de cet élément, même lorsque l'itérateur correspondant est invalidé.

Paramètres du modèle

Cette section est incomplète
Raison : Ajouter les descriptions des paramètres du template.

Types membres

Type Définition
key_type Key
mapped_type T
value_type std:: pair < const Key, T >
size_type Type entier non signé (généralement std::size_t )
difference_type Type entier signé (généralement 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 et ConstexprIterator (depuis C++26) vers value_type
const_iterator LegacyForwardIterator et ConstexprIterator (depuis C++26) vers const value_type
local_iterator Type d'itérateur dont la catégorie, la valeur, la différence, le pointeur et
les types de référence sont identiques à iterator . Cet itérateur
peut être utilisé pour parcourir un seul compartiment mais pas entre les compartiments
const_local_iterator Type d'itérateur dont la catégorie, la valeur, la différence, le pointeur et
les types de référence sont identiques à const_iterator . Cet itérateur
peut être utilisé pour parcourir un seul compartiment mais pas entre les compartiments
node_type (depuis C++17) une spécialisation de node handle représentant un nœud de conteneur
insert_return_type (depuis C++17) type décrivant le résultat de l'insertion d'un node_type , une spécialisation de

template < class Iter, class NodeType >
struct /*unspecified*/
{
Iter     position ;
bool inserted ;
NodeType node ;
} ;
instanciée avec les arguments de modèle iterator et node_type .

Fonctions membres

construit l' unordered_map
(fonction membre publique)
détruit l' unordered_map
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)
retourne l'allocateur associé
(fonction membre publique)
Itérateurs
retourne un itérateur vers le début
(fonction membre publique)
retourne un itérateur vers la fin
(fonction membre publique)
Capacité
vérifie si le conteneur est vide
(fonction membre publique)
retourne le nombre d'éléments
(fonction membre publique)
retourne le nombre maximum possible d'éléments
(fonction membre publique)
Modificateurs
efface le contenu
(fonction membre publique)
insère des éléments ou des nœuds (depuis C++17)
(fonction membre publique)
(C++23)
insère une plage d'éléments
(fonction membre publique)
(C++17)
insère un élément ou assigne à l'élément actuel si la clé existe déjà
(fonction membre publique)
construit un élément en place
(fonction membre publique)
construit des éléments en place en utilisant un indice
(fonction membre publique)
(C++17)
insère en place si la clé n'existe pas, ne fait rien si la clé existe
(fonction membre publique)
efface les éléments
(fonction membre publique)
échange le contenu
(fonction membre publique)
(C++17)
extrait les nœuds du conteneur
(fonction membre publique)
(C++17)
fusionne les nœuds d'un autre conteneur
(fonction membre publique)
Recherche
accéder à l'élément spécifié avec vérification des limites
(fonction membre publique)
accéder ou insérer l'élément spécifié
(fonction membre publique)
renvoie le nombre d'éléments correspondant à une clé spécifique
(fonction membre publique)
trouve l'élément avec une clé spécifique
(fonction membre publique)
(C++20)
vérifie si le conteneur contient un élément avec une clé spécifique
(fonction membre publique)
renvoie la plage d'éléments correspondant à une clé spécifique
(fonction membre publique)
Interface de compartiment
retourne un itérateur vers le début du compartiment spécifié
(fonction membre publique)
retourne un itérateur vers la fin du compartiment spécifié
(fonction membre publique)
renvoie le nombre de compartiments
(fonction membre publique)
renvoie le nombre maximum de compartiments
(fonction membre publique)
renvoie le nombre d'éléments dans un bucket spécifique
(fonction membre publique)
renvoie le compartiment pour une clé spécifique
(fonction membre publique)
Politique de hachage
renvoie le nombre moyen d'éléments par compartiment
(fonction membre publique)
gère le nombre moyen maximum d'éléments par compartiment
(fonction membre publique)
réserve au moins le nombre spécifié de compartiments et régénère la table de hachage
(fonction membre publique)
réserve de l'espace pour au moins le nombre spécifié d'éléments et régénère la table de hachage
(fonction membre publique)
Observateurs
retourne la fonction utilisée pour hacher les clés
(fonction membre publique)
renvoie la fonction utilisée pour comparer les clés pour l'égalité
(fonction membre publique)

Fonctions non membres

(C++11) (C++11) (supprimé en C++20)
compare les valeurs dans l'unordered_map
(modèle de fonction)
(C++11)
spécialise l'algorithme std::swap
(modèle de fonction)
(C++20)
efface tous les éléments satisfaisant des critères spécifiques
(modèle de fonction)

Guides de déduction

(depuis C++17)

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion de plages pour les conteneurs
__cpp_lib_constexpr_unordered_map 202502L (C++26) constexpr std::unordered_map

Exemple

Exécuter ce code 
#include <iostream>
#include <string>
#include <unordered_map>
int main()
{
    // Créer un unordered_map de trois chaînes (qui mappent vers des chaînes)
    std::unordered_map<std::string, std::string> u =
    {
        {"RED", "#FF0000"},
        {"GREEN", "#00FF00"},
        {"BLUE", "#0000FF"}
    };
    // Fonction lambda utilitaire pour afficher les paires clé-valeur
    auto print_key_value = [](const auto& key, const auto& value)
    {
        std::cout << "Key:[" << key << "] Value:[" << value << "]\n";
    };
    std::cout << "Itérer et afficher les paires clé-valeur de unordered_map, en étant\n"
                 "explicite avec leurs types:\n";
    for (const std::pair<const std::string, std::string>& n : u)
        print_key_value(n.first, n.second);
    std::cout << "\nItérer et afficher les paires clé-valeur en utilisant la liaison structurée C++17:\n";
    for (const auto& [key, value] : u)
        print_key_value(key, value);
    // Ajouter deux nouvelles entrées à l'unordered_map
    u["BLACK"] = "#000000";
    u["WHITE"] = "#FFFFFF";
    std::cout << "\nAfficher les valeurs par clé:\n"
                 "Le HEX de la couleur ROUGE est:[" << u["RED"] << "]\n"
                 "Le HEX de la couleur NOIR est:[" << u["BLACK"] << "]\n\n";
    std::cout << "Utiliser l'opérateur[] avec une clé inexistante pour insérer une nouvelle paire clé-valeur:\n";
    print_key_value("new_key", u["new_key"]);
    std::cout << "\nItérer et afficher les paires clé-valeur, en utilisant `auto`;\n"
                 "new_key fait maintenant partie des clés de la map:\n";
    for (const auto& n : u)
        print_key_value(n.first, n.second);
}

Sortie possible : 

Itérer et afficher les paires clé-valeur de unordered_map, en étant
explicite avec leurs types:
Key:[BLUE] Value:[#0000FF]
Key:[GREEN] Value:[#00FF00]
Key:[RED] Value:[#FF0000]
Itérer et afficher les paires clé-valeur en utilisant la liaison structurée C++17:
Key:[BLUE] Value:[#0000FF]
Key:[GREEN] Value:[#00FF00]
Key:[RED] Value:[#FF0000]
Afficher les valeurs par clé:
Le HEX de la couleur ROUGE est:[#FF0000]
Le HEX de la couleur NOIR est:[#000000]
Utiliser l'opérateur[] avec une clé inexistante pour insérer une nouvelle paire clé-valeur:
Key:[new_key] Value:[]
Itérer et afficher les paires clé-valeur, en utilisant `auto`;
new_key fait maintenant partie des clés de la 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]

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 Applicable à Comportement publié Comportement corrigé
LWG 2050 C++11 les définitions de reference , const_reference , pointer
et const_pointer étaient basées sur allocator_type 		basées sur value_type et
std::allocator_traits

Voir aussi

(C++11)
collection de paires clé-valeur, hachée par clés
(modèle de classe)
collection de paires clé-valeur, triée par clés, clés uniques
(modèle de classe)
(C++23)
adapte deux conteneurs pour fournir une collection de paires clé-valeur, triée par clés uniques
(modèle de classe)