Namespaces
Variants

std:: unordered_multimap

From cppreference.net
C++
Containers library
std::unordered_multimap
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_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)

Table des matières

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) vers value_type
const_iterator LegacyForwardIterator et ConstexprIterator (depuis C++26) vers const value_type
local_iterator Un type d'itérateur dont la catégorie, la valeur, la différence, le pointeur et
les types de 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 la catégorie, la valeur, la différence, le pointeur et
les types de 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

Fonctions membres

construit l' unordered_multimap
(fonction membre publique)
détruit l' unordered_multimap
(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)
construit l'élément en place
(fonction membre publique)
construit des éléments en place en utilisant un indice
(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
retourne 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)
retourne le nombre maximum de compartiments
(fonction membre publique)
renvoie le nombre d'éléments dans un compartiment spécifique
(fonction membre publique)
renvoie le compartiment pour une clé spécifique
(fonction membre publique)
Politique de hachage
retourne 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
renvoie 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_multimap
(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_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

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