set (STL/CLR)

Article
06/10/2015

La classe de 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 set pour gérer une séquence d'éléments en tant qu'arbre (presque) équilibré de noeuds, chacun stockant un élément.

Dans la description ci-dessous, GValue est le même que GKey, qui est à son tour identique à Key sauf si ce dernier est un type de référence, auquel cas il s'agit Key^.

template<typename Key>
    ref class set
        :   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.

Membres

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

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

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

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
IEnumerable	Parcourir les éléments.
ICollection	Maintenir le 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 définissez : : key_compare (STL/CLR). Vous pouvez spécifier l'objet délégué stocké lorsque vous construisez l'ensemble ; 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 définissez : : key_comp (STL/CLR)().

Un objet délégué de la sorte doit imposer un ordre strict faible sur les clés du type définissez : : 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 vrai, alors key_comp()(Y, X) doit être faux.

Si key_comp()(X, Y) est vrai, alors on dit que X commandé avant Y.

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

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

Chaque élément sert de clé et de valeur. 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 ensemble prend en charge les itérateurs bidirectionnels, ce qui signifie que vous pouvez passer à des éléments adjacents donnés 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 définissez : : 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 d'ensemble pour atteindre le nœud principal, puis il testera son égalité à end(). Mais vous ne pouvez pas déréférencer l'itérateur retourné par end().

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

Un itérateur d'ensemble stocke un gestionnaire de son nœud d'ensemble, qui lui même stocke un gestionnaire vers son conteneur associé. Vous pouvez utiliser des itérateurs uniquement avec leurs objets conteneurs associés. Un itérateur d'ensemble reste valide tant que le nœud d'ensemble associé est associé à un certain ensemble. De plus, un itérateur valide est déréférençable -- vous pouvez l'utiliser pour accéder ou modifier la valeur de l'élément qu'il indique -- tant qu'il n'est 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 not ses éléments.