std:: unordered_multimap

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_multimap ;	(1)	(depuis C++11)
namespace pmr { template < class Key, class T, class Hash = std:: hash < Key > , class Pred = std:: equal_to < Key > > using unordered_multimap = std :: unordered_multimap < Key, T, Hash, Pred, std:: pmr :: polymorphic_allocator < std:: pair < const Key, T >>> ; }	(2)	(depuis C++17)

std::unordered_multimap est un conteneur associatif non ordonné qui prend en charge des clés équivalentes (un unordered_multimap peut contenir plusieurs copies de chaque valeur de clé) et qui associe des valeurs d'un autre type aux clés. La classe unordered_multimap prend en charge les itérateurs avant. La recherche, l'insertion et la suppression ont une complexité en temps constant en moyenne.

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 hash de sa clé. Cela permet un accès rapide aux éléments individuels, car une fois le hash calculé, il fait référence au compartiment exact où l'élément est placé.

L'ordre d'itération de ce conteneur n'est pas requis d'être stable (ainsi, par exemple, std::equal ne peut pas être utilisé pour comparer deux std::unordered_multimap s), sauf que chaque groupe d'éléments dont les clés sont équivalentes (comparées égales avec key_eq() comme comparateur) forme un sous-intervalle contigu dans l'ordre d'itération, également accessible avec equal_range() .

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

Toutes les fonctions membres de


          std::unordered_multimap

sont constexpr : il est possible de créer et d'utiliser des objets


          std::unordered_multimap

lors de l'évaluation d'une expression constante.

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

(depuis C++26)

Paramètres du modèle

Cette section est incomplète
Motif : Ajouter les descriptions des paramètres du modèle.

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) à `value_type`
`const_iterator`	LegacyForwardIterator et ConstexprIterator(depuis C++26) à `const value_type`
`local_iterator`	un type itérateur dont les types catégorie, valeur, différence, pointeur et référence sont les mêmes que `iterator`. Cet itérateur peut être utilisé pour itérer à travers un seul compartiment mais pas entre les compartiments
`const_local_iterator`	un type itérateur dont les types catégorie, valeur, différence, pointeur et référence sont les mêmes que `const_iterator`. Cet itérateur peut être utilisé pour itérer à travers 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

Fonctions membres

(constructor)	construit l' `unordered_multimap` (fonction membre publique)
(destructor)	détruit l' `unordered_multimap` (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)
emplace	construit l'élément en place (fonction membre publique)
emplace_hint	construit des éléments en place en utilisant un indice (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
count	retourne 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	retourne le nombre maximum de compartiments (fonction membre publique)
bucket_size	renvoie le nombre d'éléments dans un compartiment spécifique (fonction membre publique)
bucket	renvoie le compartiment pour une clé spécifique (fonction membre publique)
Politique de hachage
load_factor	retourne 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	renvoie 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_multimap (modèle de fonction)
std::swap (std::unordered_multimap) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
erase_if (std::unordered_multimap) (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_multimap`

Exemple

Cette section est incomplète
Raison : aucun exemple

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_map (C++11)	collection de paires clé-valeur, hachée par clés, clés uniques (modèle de classe)
multimap	collection de paires clé-valeur, triée par clés (modèle de classe)
flat_multimap (C++23)	adapte deux conteneurs pour fournir une collection de paires clé-valeur, triée par clés (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_multimap

Contenu

Paramètres du modèle

Types membres

Fonctions membres

Itérateurs

Capacité

Modificateurs

Recherche

Interface de compartiment

Politique de hachage