std:: flat_multimap

Défini dans l'en-tête <flat_map>
template < class Key, class T, class Compare = std:: less < Key > , class KeyContainer = std:: vector < Key > , class MappedContainer = std:: vector < T > > class flat_multimap ;		(depuis C++23)

Le flat multimap est un adaptateur de conteneur qui fournit les fonctionnalités d'un conteneur associatif contenant des paires clé-valeur, tout en permettant plusieurs entrées avec la même valeur de clé. Les clés sont triées en utilisant la fonction de comparaison Compare .

Le modèle de classe flat_multimap agit comme un wrapper pour les deux conteneurs sous-jacents, passés en tant qu'objets de type KeyContainer et MappedContainer respectivement. Le premier conteneur est trié, et pour chaque clé sa valeur correspondante se trouve dans le deuxième conteneur au même index (décalage). Le nombre d'éléments dans les deux conteneurs est identique.

Partout où la bibliothèque standard utilise les exigences Compare , l'unicité est déterminée en utilisant la relation d'équivalence. Informellement, 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::flat_multimap satisfait aux exigences de Container , ReversibleContainer , exigences optionnelles de conteneur , et toutes les exigences de AssociativeContainer (y compris la complexité de recherche logarithmique), sauf que :

• les exigences relatives aux nœuds ne sont pas applicables,
• les exigences d'invalidation des itérateurs diffèrent,
• la complexité des opérations d'insertion et d'effacement est linéaire.

Un multimap plat prend en charge la plupart des AssociativeContainer opérations qui utilisent des clés équivalentes.

Toutes les fonctions membres de std::flat_multimap sont constexpr : il est possible de créer et d'utiliser des objets std::flat_multimap lors de l'évaluation d'une expression constante. Cependant, les objets std::flat_multimap 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)

Table des matières 1 Invalidation des itérateurs 2 Paramètres du modèle 3 Types membres 4 Classes membres 5 Objets membres 6 Fonctions membres 6.1 Itérateurs 6.2 Capacité 6.3 Modificateurs 6.4 Recherche 6.5 Observateurs 7 Fonctions non membres 8 Classes auxiliaires 9 Étiquettes 10 Guides de déduction 11 Notes 12 Exemple 13 Voir aussi

Invalidation des itérateurs

Cette section est incomplète

Paramètres du modèle

Key	-	Le type des clés. Le programme est mal formé si Key n'est pas du même type que KeyContainer::value_type .
T	-	Le type des valeurs mappées. Le programme est mal formé si T n'est pas du même type que MappedContainer::value_type .
Compare	-	Un type Compare fournissant un ordre strict faible.
KeyContainer MappedContainer	-	Les types des conteneurs sous-jacents SequenceContainer pour stocker respectivement les clés et les valeurs mappées. Les itérateurs de ces conteneurs doivent satisfaire LegacyRandomAccessIterator ou modéliser random_access_iterator . Les invocations de leurs fonctions membres size et max_size ne doivent pas sortir via une exception. Les conteneurs standards std::vector et std::deque satisfont à ces exigences.

Types membres

Type	Définition
key_container_type	KeyContainer
mapped_container_type	MappedContainer
key_type	Key
mapped_type	T
value_type	std:: pair < key_type, mapped_type >
key_compare	Compare
reference	std:: pair < const key_type & , mapped_type & >
const_reference	std:: pair < const key_type & , const mapped_type & >
size_type	std::size_t
difference_type	std::ptrdiff_t
iterator	défini par l'implémentation LegacyInputIterator , ConstexprIterator (depuis C++26) et random_access_iterator vers value_type
const_iterator	défini par l'implémentation LegacyInputIterator , ConstexprIterator (depuis C++26) et random_access_iterator vers const value_type
reverse_iterator	std:: reverse_iterator < iterator >
const_reverse_iterator	std:: reverse_iterator < const_iterator >
containers	type décrivant les conteneurs sous-jacents struct containers { key_container_type keys ; mapped_container_type values ; } ;

Classes membres

value_compare

compare les objets de type value_type (classe)

Objets membres

Membre	Description
containers c (privé)	les conteneurs adaptés ( objet membre d'exposition uniquement* )
key_compare compare (privé)	l'objet fonction de comparaison ( objet membre d'exposition uniquement* )

Fonctions membres

(constructeur)	construit le flat_multimap (fonction membre publique)
(destructor) (implicitly declared)	détruit chaque élément de l'adaptateur de conteneur (fonction membre publique)
operator=	assigne des valeurs à l'adaptateur de conteneur (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)
rbegin crbegin	retourne un itérateur inverse vers le début (fonction membre publique)
rend crend	retourne un itérateur inverse vers la fin (fonction membre publique)
Capacité
empty	vérifie si l'adaptateur de 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
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)
insert	insère des éléments (fonction membre publique)
insert_range	insère une plage d'éléments (fonction membre publique)
extract	extrait les conteneurs sous-jacents (fonction membre publique)
replace	remplace les conteneurs sous-jacents (fonction membre publique)
erase	efface les éléments (fonction membre publique)
swap	échange le contenu (fonction membre publique)
clear	efface le contenu (fonction membre publique)
Recherche
find	trouve l'élément avec une clé spécifique (fonction membre publique)
count	retourne le nombre d'éléments correspondant à une clé spécifique (fonction membre publique)
contains	vérifie si le conteneur contient un élément avec 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)
equal_range	retourne la plage d'éléments correspondant à une clé spécifique (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)
keys	accès direct au conteneur de clés sous-jacent (fonction membre publique)
values	accès direct au conteneur de valeurs sous-jacent (fonction membre publique)

Fonctions non membres

operator== operator<=> (C++23)	compare lexicographiquement les valeurs de deux flat_multimap s (modèle de fonction)
std::swap (std::flat_multimap) (C++23)	spécialise l'algorithme std::swap (modèle de fonction)
erase_if (std::flat_multimap) (C++23)	efface tous les éléments satisfaisant des critères spécifiques (modèle de fonction)

Classes d'assistance

std::uses_allocator <std::flat_multimap> (C++23)

spécialise le std::uses_allocator trait de type (spécialisation de modèle de classe)

Étiquettes

sorted_equivalent sorted_equivalent_t (C++23)

indique que les éléments d'une plage sont triés (l'unicité n'est pas requise) (balise)

Guides de déduction

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 fonction utilisant ces deux types comme types de paramètres peut violer la Règle de Définition Unique . Étant donné que iterator est convertible en const_iterator , une fonction unique avec un const_iterator comme type de paramètre fonctionnera à la place.

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
__cpp_lib_flat_map	202207L	(C++23)	std::flat_map et std::flat_multimap
__cpp_lib_constexpr_flat_map	202502L	(C++26)	constexpr std::flat_multimap

Exemple

Cette section est incomplète Raison : aucun exemple

Voir aussi

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