std:: unordered_map

From fr.cppreference.net

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)

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`	un type d'itérateur dont les catégories, types de valeur, différence, pointeur et référence sont les mêmes que `iterator`. Cet itérateur peut être utilisé pour parcourir un seul compartiment mais pas entre les compartiments
`const_local_iterator`	un type d'itérateur dont les catégories, types de valeur, différence, pointeur et référence sont les mêmes que `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

(constructeur)	construit l' `unordered_map` (fonction membre publique)
(destructor)	détruit l' `unordered_map` (fonction membre publique)
operator=	assigne des valeurs au conteneur (fonction membre publique)
get_allocator	retourne l'allocateur associé (fonction membre publique)
Itérateurs
begin cbegin	retourne un itérateur vers le début (fonction membre publique)
end cend	retourne un itérateur vers la fin (fonction membre publique)
Capacité
empty	vérifie si le conteneur est vide (fonction membre publique)
size	retourne le nombre d'éléments (fonction membre publique)
max_size	retourne le nombre maximum possible d'éléments (fonction membre publique)
Modificateurs
clear	efface le contenu (fonction membre publique)
insert	insère des éléments ou des nœuds (depuis C++17) (fonction membre publique)
insert_range (C++23)	insère une plage d'éléments (fonction membre publique)
insert_or_assign (C++17)	insère un élément ou assigne à l'élément actuel si la clé existe déjà (fonction membre publique)
emplace	construit un élément en place (fonction membre publique)
emplace_hint	construit des éléments en place en utilisant un indice (fonction membre publique)
try_emplace (C++17)	insère en place si la clé n'existe pas, ne fait rien si la clé existe (fonction membre publique)
erase	efface les éléments (fonction membre publique)
swap	échange le contenu (fonction membre publique)
extract (C++17)	extrait les nœuds du conteneur (fonction membre publique)
merge (C++17)	fusionne les nœuds d'un autre conteneur (fonction membre publique)
Recherche
at	accéder à l'élément spécifié avec vérification des limites (fonction membre publique)
operator[]	accéder ou insérer l'élément spécifié (fonction membre publique)
count	renvoie le nombre d'éléments correspondant à une clé spécifique (fonction membre publique)
find	trouve l'élément avec une clé spécifique (fonction membre publique)
contains (C++20)	vérifie si le conteneur contient un élément avec une clé spécifique (fonction membre publique)
equal_range	renvoie la plage d'éléments correspondant à une clé spécifique (fonction membre publique)
Interface de compartiment
begin (size_type) cbegin (size_type)	retourne un itérateur vers le début du compartiment spécifié (fonction membre publique)
end (size_type) cend (size_type)	retourne un itérateur vers la fin du compartiment spécifié (fonction membre publique)
bucket_count	renvoie le nombre de compartiments (fonction membre publique)
max_bucket_count	renvoie le nombre maximum de compartiments (fonction membre publique)
bucket_size	renvoie le nombre d'éléments dans un bucket spécifique (fonction membre publique)
bucket	renvoie le compartiment pour une clé spécifique (fonction membre publique)
Politique de hachage
load_factor	renvoie le nombre moyen d'éléments par compartiment (fonction membre publique)
max_load_factor	gère le nombre moyen maximum d'éléments par compartiment (fonction membre publique)
rehash	réserve au moins le nombre spécifié de compartiments et régénère la table de hachage (fonction membre publique)
reserve	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
hash_function	retourne la fonction utilisée pour hacher les clés (fonction membre publique)
key_eq	renvoie la fonction utilisée pour comparer les clés pour l'égalité (fonction membre publique)

Fonctions non membres

operator== operator!= (C++11) (C++11) (supprimé en C++20)	compare les valeurs dans l'unordered_map (modèle de fonction)
std::swap (std::unordered_map) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
erase_if (std::unordered_map) (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

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

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

node-handle (C++17)
Sequence
array (C++11)
vector
vector <bool>
inplace_vector (C++26)
hive (C++26)
deque
forward_list (C++11)
list
Associative
set
multiset
map
multimap
Unordered associative
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptors
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
Views
span (C++20)
mdspan (C++23)
Tables
Iterator invalidation
Member function table
Non-member function table

fr.cppreference.net

Namespaces

Variants

std:: unordered_map

Sommaire

Invalidation des itérateurs

Notes

Paramètres du modèle

Types membres

Fonctions membres

Itérateurs

Capacité

Modificateurs

Recherche

Interface de compartiment

Politique de hachage

Observateurs

Fonctions non membres

Guides de déduction

Notes

Exemple

Rapports de défauts

Voir aussi