hash_map (STL/CLR)

Article
06/07/2013

La classe de modèle décrit un objet qui contrôle une séquence de la longueur variée d'éléments qui a accès bidirectionnel.Vous utilisez le conteneur hash_map pour gérer une séquence d'éléments en tant que table de hachage, chaque entrée de table enregistrant une liste liée bidirectionnelle de nœuds, et chaque nœud enregistrement d'un élément.Un élément se compose d'une clé, pour classer la séquence, et une valeur mappée, qui devient le long de l'astuce.

Dans la description ci-après, GValue est identique à :

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

où :

GKey est identique qu' Key à moins que ce dernier soit un type référence, auquel cas c'est Key^

GMapped est identique qu' Mapped à moins que ce dernier soit un type référence, auquel cas c'est Mapped^

template<typename Key,
    typename Mapped>
    ref class hash_map
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        System::Collections::Generic::IDictionary<Gkey, GMapped>,
        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 autre Composant d'un élément de la séquence est contrôlée.

Membres

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

Fonction membre	Description
hash_map::begin (STL/CLR)	Désigne le début de la séquence contrôlée.
hash_map::bucket_count (STL/CLR)	Compte le nombre de compartiments restant.
hash_map::clear (STL/CLR)	Supprime tous les éléments.
hash_map::count (STL/CLR)	Compte des éléments qui correspondent à une clé spécifiée.
hash_map::empty (STL/CLR)	Teste si aucun élément n'est présent.
hash_map::end (STL/CLR)	Désigne la fin de la séquence contrôlée.
hash_map::equal_range (STL/CLR)	Les recherches s'étendent qui correspond à une clé spécifiée.
hash_map::erase (STL/CLR)	Supprime les éléments placés aux positions spécifiées.
hash_map::find (STL/CLR)	Recherche un élément qui correspond à une clé spécifiée.
hash_map::hash_delegate (STL/CLR)	Copie le délégué de hachage pour une clé.
hash_map::hash_map (STL/CLR)	Construit un objet.
hash_map::insert (STL/CLR)	Ajoute des éléments.
hash_map::key_comp (STL/CLR)	Copie le délégué classement pour deux clés.
hash_map::load_factor (STL/CLR)	Compte les éléments moyens par compartiment.
hash_map::lower_bound (STL/CLR)	Recherche le début de la plage qui correspond à une clé spécifiée.
hash_map::make_value (STL/CLR)	Construit un objet valeur.
hash_map::max_load_factor (STL/CLR)	Obtient ou définit des éléments de threads compartiment.
hash_map::rbegin (STL/CLR)	Désigne le début de la séquence contrôlée inversée.
hash_map::rehash (STL/CLR)	Régénère la table de hachage.
hash_map::rend (STL/CLR)	Désigne la fin de la séquence contrôlée inversée.
hash_map::size (STL/CLR)	Compte le nombre d'éléments.
hash_map::swap (STL/CLR)	Échange le contenu de deux conteneurs.
hash_map::to_array (STL/CLR)	Copie la séquence contrôlée à un nouveau tableau.
hash_map::upper_bound (STL/CLR)	Fin de recherche de la plage qui correspond à une clé spécifiée.
hash_map::value_comp (STL/CLR)	Copie le délégué classement pour deux valeurs d'élément.

Opérateur	Description
hash_map::operator= (STL/CLR)	Remplace la séquence contrôlée.
hash_map::operator[] (STL/CLR)	Mappe une clé à sa valeur mappée associée.

Interfaces

Interface	Description
ICloneable	Dupliquez un objet.
IEnumerable	Séquence de parcourir les éléments.
ICollection	Maintenez le groupe d'éléments.
IEnumerable<T>	Séquence par des éléments typés.
ICollection<T>	Maintenez le groupe d'éléments typés.
IDictionary<TKey, TValue>	Maintenez le groupe {clé, valeur} de paires.
IHash<Clé, value>	Maintenez le conteneur générique.

Notes

L'objet alloue et libère le 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), la gestion efficacement la liste entière comme une séquence de sous-listes, ou de compartiments.Elle n'insère jamais des éléments dans un compartiment qu'elle stocke classée en modifiant les liens entre les nœuds, en copiant le contenu d'un nœud à un autre.Cela signifie que vous pouvez insérer et supprimer des éléments librement sans éléments restants inquiétants.

L'objet classe chaque compartiment qu'il contrôle en appelant un objet délégué stocké de type hash_set::key_compare (STL/CLR).Vous pouvez spécifier l'objet délégué stocké lorsque vous construisez le hash_set ; si vous ne spécifiez pas d'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)().Un tel objet délégué doit définir le classement équivalent entre les clés du type hash_set::key_type (STL/CLR).Cela signifie, parce que deux clés d' X et Y:

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

Si key_comp()(X, Y) && key_comp()(Y, X) condition est vraie, on dit qu' X et Y ont le classement équivalent.

Toute règle de classement qui se comporte comme operator<=(key_type, key_type), operator>=(key_type, key_type) ou operator==(key_type, key_type) définit le classement eqivalent.

Notez que le conteneur garantit uniquement que les éléments dont les clés ont le classement d'équivalent (et qui hachent à la même valeur entière) sont adjacents dans un compartiment.Contrairement à la classe de modèle hash_multimap (STL/CLR), un objet de classe de modèle hash_map garantit que les clés pour tous les éléments sont uniques.(Aucune deux clés n'ont le classement équivalent.)

L'objet détermine l'compartiment doit contenir une clé de classement 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 pas d'objet délégué, la valeur par défaut est la fonction System::Object::hash_value(key_type).Cela signifie, pour toutes clés X et Y:

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

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

Chaque élément contient une clé séparée et une valeur mappée.La séquence sont représentées d'une manière qui permet la recherche, l'insertion, et la suppression d'un élément arbitraire avec un certain nombre d'opérations qui est indépendant du nombre d'éléments dans la séquence (le temps fixe) -- au moins dans l'idéal.De plus, insérez un élément n'invalide aucun itérateur, et suppression d'un élément invalide uniquement les itérateurs qui pointent vers l'élément supprimé.

Si les valeurs hachées ne sont pas régulièrement distribuées, toutefois, une table de hachage peut se dégénérer.Dans l'extrème -- pour une fonction de hachage qui retourne toujours la même valeur -- la recherche, l'insertion, et la suppression sont proportionnelles au nombre d'éléments dans la séquence (temps linéaire).Le conteneur essaie de choisir une fonction de hachage raisonnable, une taille moyenne du compartiment, et une taille hashtable (nombre total de compartiments), vous pouvez substituer l'une ou l'ensemble des choix.Consultez, par exemple, les fonctions hash_set::max_load_factor (STL/CLR) et hash_set::rehash (STL/CLR).

Un hash_map prend en charge des itérateurs bidirectionnelles, ce qui signifie que vous pouvez exécuter pas aux éléments adjacents dotés d'un itérateur qui indique un élément dans la séquence contrôlée.Un nœud principal particulier correspond à l'itérateur retourné par hash_map::end (STL/CLR)().Vous pouvez décrémenter cet itérateur pour atteindre le dernier élément de la séquence contrôlée, le cas échéant.Vous pouvez incrémenter un itérateur de hash_map pour atteindre le nœud principal, et il comparera ensuite égale à end().Mais vous ne pouvez pas déréférencement l'itérateur retourné par end().

Notez que vous ne pouvez pas faire référence à un élément de hash_map directement donné sa position numérique -- cette opération nécessite un itérateurs d'accès aléatoire.

Un itérateur de hash_map enregistre un handle vers son nœud connexe de hash_map, qui enregistre ensuite un handle à son conteneur associé.Vous pouvez utiliser des itérateurs uniquement avec leurs objets conteneurs associés.Un itérateur de hash_map reste valide tant que son nœud connexe de hash_map être associé à un certain hash_map.De plus, un itérateur valide est dereferencable -- vous pouvez l'utiliser pour accéder ou modifier sa valeur d'élément qu'il indique -- en sachant qu'il ne soit pas égal à end().

Effaçant ou suppression d'un élément appelle le destructeur de sa valeur stockée.Détruire le conteneur efface tous les éléments.Ainsi, un conteneur dont le type d'élément est une classe de référence garantit qu'élément ne survit pas au conteneur.La notez, cependant, un conteneur de handles fait not destroy ses éléments.