hash_multimap (STL/CLR)

Article
06/10/2015

La classe du modèle décrit un objet qui contrôle la séquence de longueur variée d'éléments ayant un accès bidirectionnel. Vous utilisez le conteneur hash_multimap pour gérer une séquence d'éléments comme une table de hachage, chaque entrée de table enregistrant une liste liée bidirectionnelle de nœuds, et chaque nœud 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 hash_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::IHash<Gkey, GValue>
    { ..... };

Paramètres

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

Membres

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

Fonction membre	Description
hash_multimap : : démarrez (STL/CLR)	Désigne le début de la séquence contrôlée.
hash_multimap : : bucket_count (STL/CLR)	Compte le nombre de compartiments.
hash_multimap : : espace libre (STL/CLR)	Supprime tous les éléments.
hash_multimap : : nombre (STL/CLR)	Compte les éléments qui correspondent à une clé spécifiée.
hash_multimap : : vide (STL/CLR)	Teste si aucun élément n'est présent.
hash_multimap : : fin (STL/CLR)	Désigne la fin de la séquence contrôlée.
hash_multimap : : equal_range (STL/CLR)	Recherche la plage qui correspond à une clé spécifiée.
hash_multimap : : effacement (STL/CLR)	Supprime les éléments placés aux positions spécifiées.
hash_multimap : : recherche (STL/CLR)	Recherche un élément qui correspond à une clé spécifiée.
hash_multimap : : hash_delegate (STL/CLR)	Copie le hachage délégué pour une clé.
hash_multimap : : hash_multimap (STL/CLR)	Construit un objet container.
hash_multimap : : insertion (STL/CLR)	Ajoute les éléments.
hash_multimap : : key_comp (STL/CLR)	Copie le classement délégué pour deux clés.
hash_multimap : : load_factor (STL/CLR)	Compte le nombre moyens d'éléments par compartiment.
hash_multimap : : lower_bound (STL/CLR)	Recherche le début de la plage qui correspond à une clé spécifiée.
hash_multimap : : make_value (STL/CLR)	Construit un objet doté d'une valeur.
hash_multimap : : max_load_factor (STL/CLR)	Obtient ou définit les éléments maximum de chaque compartiment.
hash_multimap : : rbegin (STL/CLR)	Désigne le début de la séquence contrôlée inversée.
hash_multimap : : réchauffé (STL/CLR)	Régénère la table de hachage.
hash_multimap : : rend (STL/CLR)	Désigne la fin de la séquence contrôlée inversée.
hash_multimap : : taille (STL/CLR)	Compte le nombre d'éléments.
hash_multimap : : échange (STL/CLR)	Échange le contenu de deux conteneurs.
hash_multimap : : to_array (STL/CLR)	Copie la séquence contrôlée dans un tableau.
hash_multimap : : upper_bound (STL/CLR)	Recherche la fin de la plage qui correspond à une clé spécifiée.
hash_multimap : : value_comp (STL/CLR)	Copie le classement délégué pour deux valeurs d'éléments.

Opérateur	Description
hash_multimap : : operator= (STL/CLR)	Remplace la séquence contrôlée.

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
IEnumerable	Séquence à travers les éléments.
ICollection	Contient le groupe d'éléments.
IEnumerable	Séquence à travers les éléments typés.
ICollection	Contient le groupe d'éléments typés.
IHashKey<, valeur>	Contient le conteneur générique.

Notes

L'objet alloue et libère du stockage pour la séquence qu'il contrôle comme des nœuds individuels dans une liste liée bidirectionnelle. Pour accélérer l'accès, l'objet contient également un tableau de longueur variée de pointeurs dans la liste (table de hachage), gérant la liste entière comme séquence de sous-listes, ou compartiments. Il insère des éléments dans un compartiment 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 éléments restants gênants.

L'objet classifie chaque compartiment qu'il contrôle en appelant un objet délégué stockés de type hash_set : : key_compare (STL/CLR). Vous pouvez spécifier l'objet délégué stockée lorsque vous construisez le hash_set ; 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 à l'objet délégué stocké en appelant la fonction membre hash_set : : key_comp (STL/CLR)(). Cet objet délégué doit définir le classement équivalent entre les clés du type hash_set : : 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) && key_comp()(Y, X) est vrai, alors X et Y ont un classement équivalent.

Toute règle de tri qui se comporte comme operator<=(key_type, key_type), operator>=(key_type, key_type) ou operator==(key_type, key_type) définit l'ordre équivalent.

Notez que le conteneur ne garantit que les éléments dont les clés ont un classement équivalent (et qui hachent à la même valeur entière) et qui sont adjacents dans un compartiment. Contrairement à la classe de modèle hash_map (STL/CLR), un objet de classe de modèle hash_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és de manière équivalente.)

L'objet détermine quel compartiment doit contenir une clé de tri donnée en appelant un objet délégué stocké de type hash_set : : hasher (STL/CLR). Vous accédez à cet objet stocké en appelant la fonction membre hash_set : : hash_delegate (STL/CLR)() pour obtenir une valeur entière qui dépend de la valeur de clé. Vous pouvez spécifier l'objet délégué stocké lorsque vous construisez le hash_set ; si vous ne spécifiez aucun objet délégué, la valeur par défaut est la fonction System::Object::hash_value(key_type). Cela signifie, pour des clés quelconques X et Y:

hash_delegate()(X) retourne le même résultat entier à chaque appel.

Si X et Y ont un classement équivalent, alors hash_delegate()(X) doit retourner le même résultat entier que hash_delegate()(Y).

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 choisi avec un nombre d'opérations qui est indépendant du nombre d'éléments dans la séquence (à temps fixe) -- au moins dans l'idéal. 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 l'élément supprimé.

Toutefois, si les valeurs hachées ne sont pas distribuées uniformément, une table de hachage peut se dégénérer. Dans le cas extrême -- pour une fonction de hachage qui retourne toujours la même valeur -- la recherche, l'insertion, la suppression sont proportionnelles au nombre d'éléments dans la séquence (temps linéaire). Le conteneur tente de sélectionner une fonction de hachage raisonnable, la taille moyenne de création de compartiments, et une taille de table de hachage (nombre total de compartiments), mais vous pouvez remplacer tout ou une partie de ces choix. Consultez, par exemple, les fonctions hash_set : : max_load_factor (STL/CLR) et hash_set : : réchauffé (STL/CLR).

Une multimap de hachage 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 hash_multimap : : 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 de hachage 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 de hachage directement avec sa position numérique -- cela requiert un itérateur à accès aléatoire.

Un itérateur de multimap de hachage contient un descripteur vers son nœud associé à la multimap de hachage, 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 de hachage reste valide à condition que son nœud associé à la multimap de hachage soit associé à un certain ensemble de multimap de hachage. De plus, un itérateur valide est déréférencable -- vous pouvez l'utiliser pour accéder et modifier la valeur d'é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 not détruit ses éléments.