std:: unordered_multiset

From fr.cppreference.net

Défini dans l'en-tête `<unordered_set>`
template < class Key, class Hash = std:: hash < Key > , class KeyEqual = std:: equal_to < Key > , class Allocator = std:: allocator < Key > > class unordered_multiset ;	(1)	(depuis C++11)
namespace pmr { template < class Key, class Hash = std:: hash < Key > , class Pred = std:: equal_to < Key > > using unordered_multiset = std :: unordered_multiset < Key, Hash, Pred, std:: pmr :: polymorphic_allocator < Key >> ; }	(2)	(depuis C++17)

std::unordered_multiset est un conteneur associatif qui contient un ensemble d'objets potentiellement non uniques de type Key. La recherche, l'insertion et la suppression 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 valeur. Cela permet un accès rapide aux éléments individuels, car une fois le hachage 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_multiset 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_multiset satisfait aux exigences de Container , AllocatorAwareContainer , UnorderedAssociativeContainer .

Toutes les fonctions membres de


          std::unordered_multiset

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


          std::unordered_multiset

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

Cependant, les objets std::unordered_multiset 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)

Paramètres du modèle

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

Types membres

Type	Définition
`key_type`	`Key`
`value_type`	`Key`
`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`	Constant LegacyForwardIterator et ConstexprIterator(depuis C++26) à `value_type`
`const_iterator`	LegacyForwardIterator et ConstexprIterator(depuis C++26) à `const value_type`
`local_iterator`	un type d'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 dans un seul compartiment mais pas entre les compartiments
`const_local_iterator`	un type d'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 dans 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 le `unordered_multiset` (fonction membre publique)
(destructor)	détruit l' `unordered_multiset` (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 un é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)	greffe 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	retourne 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) (removed in C++20)	compare les valeurs dans le unordered_multiset (modèle de fonction)
std::swap (std::unordered_multiset) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
erase_if (std::unordered_multiset) (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

Les types membres iterator et const_iterator peuvent être des alias vers le même type. Cela signifie que définir une paire de surcharges de fonctions utilisant ces deux types comme types de paramètres peut violer la Règle de Définition Unique . Puisque iterator est convertible en const_iterator , une fonction unique avec un paramètre de type const_iterator fonctionnera à la place.

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_lib_containers_ranges`	`202202L`	(C++23)	Construction et insertion de gammes pour les conteneurs
`__cpp_lib_constexpr_unordered_set`	`202502L`	(C++26)	constexpr `std::unordered_muliset`

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_set (C++11)	collection de clés uniques, hachée par clés (modèle de classe)
multiset	collection de clés, triée par clés (modèle de classe)
flat_multiset (C++23)	adapte un conteneur pour fournir une collection de clés, 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_multiset

Contenu

Paramètres du modèle

Types membres

Fonctions membres

Itérateurs

Capacité

Modificateurs

Recherche

Interface de compartiment

Politique de hachage