std:: multimap

Défini dans l'en-tête <map>
template < class Key, class T, class Compare = std:: less < Key > , class Allocator = std:: allocator < std:: pair < const Key, T >> > class multimap ;	(1)
namespace pmr { template < class Key, class T, class Compare = std:: less < Key > > using multimap = std :: multimap < Key, T, Compare, std:: pmr :: polymorphic_allocator < std:: pair < const Key, T >>> ; }	(2)	(depuis C++17)

std::multimap est un conteneur associatif qui contient une liste triée de paires clé-valeur, tout en permettant plusieurs entrées avec la même clé. Le tri est effectué selon la fonction de comparaison Compare , appliquée aux clés. Les opérations de recherche, d'insertion et de suppression ont une complexité logarithmique.

Les itérateurs de std::multimap parcourent les éléments dans un ordre non décroissant des clés, où le non-décroissant est défini par la comparaison utilisée lors de la construction. Autrement dit, étant donné

• m , un std::multimap
• it_l et it_r , itérateurs déréférençables vers m , avec it_l < it_r .

m. value_comp ( ) ( * it_r, * it_l ) == false (du plus petit au plus grand si on utilise la comparaison par défaut).

L'ordre des paires clé-valeur dont les clés sont équivalentes par comparaison est l'ordre d'insertion et ne change pas.

(since C++11)

Partout où la bibliothèque standard utilise les Compare exigences, l'équivalence est déterminée en utilisant la relation d'équivalence comme décrit sur Compare . En termes approximatifs, deux objets a et b sont considérés équivalents si aucun n'est comparé comme inférieur à l'autre : ! comp ( a, b ) && ! comp ( b, a ) .

std::multimap satisfait aux exigences de Container , AllocatorAwareContainer , AssociativeContainer et ReversibleContainer .

Toutes les fonctions membres de std::multimap sont constexpr : il est possible de créer et d'utiliser des objets std::multimap dans l'évaluation d'une expression constante. Cependant, les objets std::multimap ne peuvent généralement pas être constexpr , car toute allocation de mémoire dynamique doit être libérée dans la même évaluation d'expression constante.

(depuis C++26)

Table des matières 1 Paramètres du modèle 2 Types membres 3 Classes membres 4 Fonctions membres 4.1 Itérateurs 4.2 Capacité 4.3 Modificateurs 4.4 Recherche 4.5 Observateurs 5 Fonctions non membres 6 Guides de déduction 7 Notes 8 Exemple 9 Rapports de défauts 10 Voir aussi

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 )
key_compare	Compare
allocator_type	Allocator
reference	value_type &
const_reference	const value_type &
pointer	Allocator::pointer (jusqu'en C++11) std:: allocator_traits < Allocator > :: pointer (depuis C++11)
const_pointer	Allocator::const_pointer (jusqu'en C++11) std:: allocator_traits < Allocator > :: const_pointer (depuis C++11)
iterator	LegacyBidirectionalIterator et ConstexprIterator (depuis C++26) vers value_type
const_iterator	LegacyBidirectionalIterator et ConstexprIterator (depuis C++26) vers const value_type
reverse_iterator	std:: reverse_iterator < iterator >
const_reverse_iterator	std:: reverse_iterator < const_iterator >
node_type (depuis C++17)	une spécialisation de node handle représentant un nœud de conteneur

Classes membres

value_compare

compare les objets de type value_type (classe)

Fonctions membres

(constructeur)	construit le multimap (fonction membre publique)
(destructor)	détruit le 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 (C++11)	retourne un itérateur vers le début (fonction membre publique)
end cend (C++11)	retourne un itérateur vers la fin (fonction membre publique)
rbegin crbegin (C++11)	retourne un itérateur inverse vers le début (fonction membre publique)
rend crend (C++11)	retourne un itérateur inverse 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 (C++11)	construit un élément en place (fonction membre publique)
emplace_hint (C++11)	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)
lower_bound	retourne un itérateur vers le premier élément non inférieur à la clé donnée (fonction membre publique)
upper_bound	retourne un itérateur vers le premier élément supérieur à la clé donnée (fonction membre publique)
Observateurs
key_comp	renvoie la fonction qui compare les clés (fonction membre publique)
value_comp	renvoie la fonction qui compare les clés dans les objets de type value_type (fonction membre publique)

Fonctions non membres

operator== operator!= operator< operator<= operator> operator>= operator<=> (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)	compare lexicographiquement les valeurs de deux multimap s (modèle de fonction)
std::swap (std::multimap)	spécialise l'algorithme std::swap (modèle de fonction)
erase_if (std::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_map	202502L	(C++26)	constexpr std::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	Appliqué à	Comportement publié	Comportement corrigé
LWG 230	C++98	Key n'était pas requis d'être CopyConstructible (une clé de type Key pourrait ne pas pouvoir être construite)	Key est également requis d'être CopyConstructible

Voir aussi

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