mappage multiple (STL/CLR)

Article
06/10/2015

La classe du modèle décrit un objet qui contrôle une séquence de longueur variable d'éléments ayant un accès bidirectionnel. Vous utilisez le conteneur multimap pour gérer une séquence d'éléments en tant qu'arbre (presque) équilibré de noeuds, chacun stockant un élément. Un élément se compose d'une clé, pour classer la séquence, et d'une valeur mappée.

Dans la description ci-dessous, GValue est la même chose que :

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

où :

GKey est la même chose que Key sauf si ce dernier est un type de référence, auquel cas il s'agit de Key^.

GMapped est la même chose que Mapped sauf si ce dernier est un type de référence, auquel cas il s'agit de Mapped^.

template<typename Key,
    typename Mapped>
    ref class multimap
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::ITree<Gkey, GValue>
    { ..... };

Paramètres

Clé
Type du composant clé d'un élément dans la séquence contrôlée.
Mapped
Le type du composant additionel d'un élément dans la séquence contrôlée.

Membres

Définition de type	Description
mappage multiple : : const_iterator (STL/CLR)	Type d'un itérateur constant pour la séquence contrôlée.
mappage multiple : : const_reference (STL/CLR)	Type d'une référence constante à un élément.
mappage multiple : : const_reverse_iterator (STL/CLR)	Le type d'un itérateur inverse constant pour la séquence contrôlée.
mappage multiple : : difference_type (STL/CLR)	Le type d'une distance (possiblement signée) entre deux éléments.
mappage multiple : : generic_container (STL/CLR)	Le type de l'interface générique pour le conteneur.
mappage multiple : : generic_iterator (STL/CLR)	Le type d'un itérateur pour l'interface générique pour le conteneur.
mappage multiple : : generic_reverse_iterator (STL/CLR)	Le type d'un itérateur inversé pour l'interface générique pour le conteneur.
mappage multiple : : generic_value (STL/CLR)	Le type d'un élément pour l'interface générique pour le conteneur.
mappage multiple : : itérateur (STL/CLR)	Type d'un itérateur pour la séquence contrôlée.
mappage multiple : : key_compare (STL/CLR)	Le classement délégue pour deux clés.
mappage multiple : : key_type (STL/CLR)	Type d'une clé de classement.
mappage multiple : : mapped_type (STL/CLR)	Le type de la valeur mappée associée à chaque clé.
mappage multiple : : référence (STL/CLR)	Type d'une référence à un élément.
mappage multiple : : reverse_iterator (STL/CLR)	Le type d'un itérateur inversé pour la séquence contrôlée.
mappage multiple : : size_type (STL/CLR)	Le type d'une distance (non-négative) entre deux éléments.
mappage multiple : : value_compare (STL/CLR)	Le classement délégué pour deux valeurs d'élements.
mappage multiple : : value_type (STL/CLR)	Le type d'un élément.

Méthode	Description
mappage multiple : : démarrez (STL/CLR)	Désigne le début de la séquence contrôlée.
mappage multiple : : espace libre (STL/CLR)	Supprime tous les éléments.
mappage multiple : : nombre (STL/CLR)	Compte les éléments qui correspondent à une clé spécifiée.
mappage multiple : : vide (STL/CLR)	Teste si aucun élément n'est présent.
mappage multiple : : fin (STL/CLR)	Désigne la fin de la séquence contrôlée.
mappage multiple : : equal_range (STL/CLR)	Recherche la plage qui correspond à une clé spécifiée.
mappage multiple : : effacement (STL/CLR)	Supprime les éléments placés aux positions spécifiées.
mappage multiple : : recherche (STL/CLR)	Recherche un élément qui correspond à une clé spécifiée.
mappage multiple : : insertion (STL/CLR)	Ajoute les éléments.
mappage multiple : : key_comp (STL/CLR)	Copie le délégué de commande pour deux clés.
mappage multiple : : lower_bound (STL/CLR)	Recherche le début de la plage qui correspond à une clé spécifiée.
mappage multiple : : make_value (STL/CLR)	Construit un objet doté d'une valeur.
mappage multiple : : mappage multiple (STL/CLR)	Construit un objet container.
mappage multiple : : rbegin (STL/CLR)	Désigne le début de la séquence contrôlée inversée.
mappage multiple : : rend (STL/CLR)	Désigne la fin de la séquence contrôlée inversée.
mappage multiple : : taille (STL/CLR)	Compte le nombre d'éléments.
mappage multiple : : échange (STL/CLR)	Échange le contenu de deux conteneurs.
mappage multiple : : to_array (STL/CLR)	Copie la séquence contrôlée dans un tableau.
mappage multiple : : upper_bound (STL/CLR)	Recherche la fin de la plage qui correspond à une clé spécifiée.
mappage multiple : : value_comp (STL/CLR)	Copie le classement délégué pour deux valeurs d'éléments.

Opérateur	Description
mappage multiple : : operator= (STL/CLR)	Remplace la séquence contrôlée.
opérateur ! = (mappage multiple) (STL/CLR)	Détermine si un objet de multimap n'est pas égal à un autre objet de multimap.
operator< (mappage multiple) (STL/CLR)	Détermine si un objet de multimap est inférieur à un autre objet de multimap.
operator<= (mappage multiple) (STL/CLR)	Détermine si un objet de multimap est inférieur ou égal à un objet de multimap.
operator== (mappage multiple) (STL/CLR)	Détermine si un objet de multimap n'est pas égal à un autre objet de multimap.
operator> (mappage multiple) (STL/CLR)	Détermine si un objet de multimap est plus grand qu'un autre objet de multimap.
operator>= (mappage multiple) (STL/CLR)	Détermine si un objet de multimap est supérieur ou égal à un objet de multimap.

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
IEnumerable	Parcourir les éléments.
ICollection	Maintenirle groupe d'éléments.
IEnumerable	Parcourir les éléments typés.
ICollection	Maintenir le groupe d'éléments typés.
ITree<Key, Value>	Maintenir le conteneur générique.

Notes

L'objet alloue et libère du stockage pour la séquence qu'il contrôle en tant que nœuds individuels. Il insère des éléments dans un arbre (presque) équilibré qu'il garde trié en modifiant les liens entre les nœuds, jamais en copiant le contenu d'un nœud vers un autre. Cela signifie que vous pouvez insérer et supprimer des éléments librement sans déranger les éléments restants.

L'objet classifie la séquence qu'il contrôle en appelant un objet délégué stocké de type mappage multiple : : key_compare (STL/CLR). Vous pouvez spécifier l'objet délégué stocké lorsque vous construisez le multimap; si vous ne spécifiez aucun objet délégué, la valeur par défaut est la comparaison operator<(key_type, key_type). Vous accédez à cet objet stocké en appelant la méthode mappage multiple : : key_comp (STL/CLR)().

Cet objet délégué doit appliquer un ordre strict faible sur les clés du type mappage multiple : : key_type (STL/CLR). Cela signifie, pour deux clés quelconques X et Y:

key_comp()(X, Y) retourne le même résultat booléen à chaque appel.

Si key_comp()(X, Y) est true, alors key_comp()(Y, X) doit être false.

Si key_comp()(X, Y) est true, alors X devient donc classé avant Y.

Si !key_comp()(X, Y) && !key_comp()(Y, X) est vrai, alors X et Y ont un classement équivalent.

Pour tout élément X qui précède Y dans la séquence contrôlée, key_comp()(Y, X) est false. (Pour l'objet délégué par défaut, les clés ne perdent jamais en valeur.) Contrairement à la classe de modèle map (STL/CLR), un objet de classe de modèle multimap n'a pas forcément besoin que les clés pour les éléments soient uniques. (Deux clés ou plus peuvent être classées de manière équivalente.)

Chaque élément contient une clé distincte et une valeur mappée. La séquence est représentée d'une manière qui autorise la recherche, l'insertion, et la suppression d'un élément aléatoire avec un nombre d'opérations proportionnel au logarithme du nombre d'éléments dans la séquence (complexité logarithmique). De plus, insérer un élément n'invalide aucun itérateur, et la suppression d'un élément invalide uniquement les itérateurs pointant vers l'élément supprimé.

Un multimap prend en charge les itérateurs bidirectionnels, ce qui signifie que vous pouvez passer aux éléments adjacents à partir d'un itérateur qui indique un élément dans la séquence contrôlée. Un nœud principal spécial correspond à l'itérateur retourné par mappage multiple : : fin (STL/CLR)(). Vous pouvez décrémenter l'itérateur pour atteindre le dernier élément de la séquence contrôlée, s'il est présent. Vous pouvez incrémenter un itérateur de multimap pour atteindre le nœud principal, et il est alors égal à end(). Mais vous ne pouvez pas déréférencer l'itérateur retourné par end().

Notez que vous ne pouvez pas faire référence à une multimap directement avec sa position numérique -- cela requiert un itérateur à accès aléatoire.

Un itérateur de multimap contient un descripteur vers son nœud associé à la multimap, qui elle-même contient un descripteur vers son conteneur associé. Vous pouvez utiliser les itérateurs uniquement avec leurs objets conteneurs associés. Un itérateur de multimap reste valide à condition que son nœud de multimap associé soit associé à un multimap. De plus, un itérateur valide est déréférencable -- vous pouvez l'utiliser pour accéder et modifier la valeur de l'élément qu'il indique -- sous réserve qu'il ne soit pas égal à end().

Effacer ou supprimer un élément appelle le destructeur pour sa valeur stockée. Détruire le conteneur efface tous les éléments. Par conséquent, un conteneur dont le type d'élément est une classe de base garantit qu'aucun élément ne survive au conteneur. Notez, toutefois, qu'un conteneur de descripteurs ne détruit pas (not) ses éléments.