map (STL/CLR)

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 map pour gérer une séquence d'éléments comme (presque) avez équilibré l'arborescence ordonnée de nœuds, chaque un élément d'inscription.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 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::ITree<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

Interfaces

Notes

L'objet alloue et libère le stockage pour la séquence qu'il contrôle comme des nœuds individuels.Il insère des éléments dans un (presque) n'a jamais équilibré l'arborescence qu'il contient 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 la séquence qu'il contrôle en appelant un objet délégué stocké de type map::key_compare (STL/CLR).Vous pouvez spécifier l'objet délégué stocké lorsque vous construisez le mappage ; 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 à cet objet stocké en appelant la fonction membre map::key_comp (STL/CLR)().

Un tel objet délégué doit appliquer le classement faible strict aux clés du type map::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) condition est vraie, key_comp()(Y, X) doit être false.

Si key_comp()(X, Y) condition est vraie, X est appelé dimensionné avant Y.

Si !key_comp()(X, Y) && !key_comp()(Y, X) condition est vraie, on dit qu' X et Y ont le 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 font baisser jamais dans une valeur.) Contrairement à la classe de modèle map (STL/CLR), un objet de classe de modèle map ne nécessite pas que les clés pour tous les éléments sont uniques.(Deux clés ou plusieurs peuvent avoir le classement équivalent.)

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 proportionnelles au logarithme du nombre d'éléments dans la séquence (temps logarithmique).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é.

Une carte 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 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 mappage 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 mappage directement donné sa position numérique -- cette opération nécessite un itérateurs d'accès aléatoire.

Un itérateur de mappage enregistre un handle vers son nœud connexe de cartes, 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 mappage reste valide tant que son nœud connexe de mappage soit associé à une certaine mappage.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.

Configuration requise

en-tête :<cliext/carte>

Cliext del'espace de noms :

Voir aussi

Référence

hash_map (STL/CLR)

hash_map (STL/CLR)

hash_multiset (STL/CLR)

hash_set (STL/CLR)

map (STL/CLR)

multiset (STL/CLR)

set (STL/CLR)

Autres ressources

Référence de bibliothèque STL/CLR