`set` (STL/CLR)

Article
10/12/2023

La classe de modèle décrit un objet qui contrôle une séquence d’éléments de longueur variable ayant un accès bidirectionnel. Vous utilisez le conteneur set pour gérer une séquence d’éléments en tant qu’arborescence ordonnée (presque) équilibrée de nœuds, chacune stockant un élément.

Dans la description ci-dessous, GValue est le même que , qui à son tour est le même que GKeyKey si ce dernier est un type ref, auquel cas il s’agit Key^.

Syntaxe

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

Key
Type du composant clé d’un élément dans la séquence contrôlée.

Spécifications

Header :<cliext/set>

Espace de noms : cliext

Déclarations

Définition de types	Description
`set::const_iterator`	Type d'un itérateur constant pour la séquence contrôlée.
`set::const_reference`	Type d'une référence constante à un élément.
`set::const_reverse_iterator`	Type d'un itérateur inserve constant pour la séquence contrôlée.
`set::difference_type`	Type d’une distance (éventuellement signée) entre deux éléments.
`set::generic_container`	Type de l’interface générique pour le conteneur.
`set::generic_iterator`	Type d’itérateur pour l’interface générique du conteneur.
`set::generic_reverse_iterator`	Type d’itérateur inverse pour l’interface générique du conteneur.
`set::generic_value`	Type d’un élément pour l’interface générique du conteneur.
`set::iterator`	Type d'un itérateur pour la séquence contrôlée.
`set::key_compare`	Délégué de classement pour deux clés.
`set::key_type`	Type d'une clé de tri.
`set::reference`	Type d'une référence à un élément.
`set::reverse_iterator`	Type d'un itérateur inverse pour la séquence contrôlée.
`set::size_type`	Type d’une distance (non négative) entre deux éléments.
`set::value_compare`	Délégué de classement pour deux valeurs d’élément.
`set::value_type`	Type d’un élément.

Fonction membre	Description
`set::begin`	Désigne le début de la séquence contrôlée.
`set::clear`	Supprime tous les éléments.
`set::count`	Compte les éléments correspondant à une clé spécifiée.
`set::empty`	Vérifie l'absence d'éléments.
`set::end`	Désigne la fin de la séquence contrôlée.
`set::equal_range`	Recherche une plage qui correspond à une clé spécifiée.
`set::erase`	Supprime les éléments placés aux positions spécifiées.
`set::find`	Recherche un élément qui correspond à une clé spécifiée.
`set::insert`	Ajoute des éléments.
`set::key_comp`	Copie le délégué de classement pour deux clés.
`set::lower_bound`	Recherche le début de la plage qui correspond à une clé spécifiée.
`set::make_value`	Construit un objet valeur.
`set::rbegin`	Désigne le début de la séquence contrôlée inverse.
`set::rend`	Désigne la fin de la séquence contrôlée inverse.
`set::set`	Construit un objet conteneur.
`set::size`	Compte le nombre d'éléments.
`set::swap`	Échange le contenu de deux conteneurs.
`set::to_array`	Copie la séquence contrôlée dans un nouveau tableau.
`set::upper_bound`	Recherche la fin de la plage qui correspond à une clé spécifiée.
`set::value_comp`	Copie le délégué de classement pour deux valeurs d’élément.

Opérateur	Description
`set::operator=`	Remplace la séquence contrôlée.
`operator!=` (set)	Détermine si un `set` objet n’est pas égal à un autre `set` objet.
`operator<` (set)	Détermine si un `set` objet est inférieur à un autre `set` objet.
`operator<=` (set)	Détermine si un `set` objet est inférieur ou égal à un autre `set` objet.
`operator==` (set)	Détermine si un `set` objet est égal à un autre `set` objet.
`operator>` (set)	Détermine si un `set` objet est supérieur à un autre `set` objet.
`operator>=` (set)	Détermine si un `set` objet est supérieur ou égal à un autre `set` objet.

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
IEnumerable	Séquencer des éléments.
ICollection	Conservez le groupe d’éléments.
IEnumerable<T>	Séquence à l’aide d’éléments typés.
ICollection<T>	Conservez le groupe d’éléments typés.
`ITree<Key, Value>`	Gérer le conteneur générique.

Notes

L’objet alloue et libère le stockage pour la séquence qu’il contrôle en tant que nœuds individuels. Il insère des éléments dans une arborescence (presque) équilibrée qu’elle conserve ordonnée 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 librement des éléments sans déranger les éléments restants.

L’objet commande la séquence qu’il contrôle en appelant un objet délégué stocké de type set::key_compare. Vous pouvez spécifier l’objet délégué stocké lorsque vous construisez le jeu ; 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 fonction set::key_compmembre.

Un tel objet délégué doit imposer un ordre faible strict sur les clés de type set::key_type. Cela signifie que, pour deux clés X et Y:

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

Si key_comp()(X, Y) c’est vrai, il key_comp()(Y, X) doit être faux.

Si key_comp()(X, Y) c’est vrai, on X dit d’être ordonné avant Y.

Si !key_comp()(X, Y) && !key_comp()(Y, X) c’est vrai, alors X et Y sont dits avoir un ordre équivalent.

Pour tout élément X qui précède Y dans la séquence contrôlée, key_comp()(Y, X) a la valeur false. (Pour l’objet délégué par défaut, les clés ne diminuent jamais en valeur.) Contrairement au jeu de classes de modèle, un objet de classe set de modèle ne nécessite pas que les clés pour tous les éléments soient uniques. (Deux clés ou plus peuvent avoir un ordre équivalent.)

Chaque élément sert à la fois de clé et de valeur. La séquence est représentée de manière à permettre la recherche, l’insertion et la suppression d’un élément arbitraire dans le temps logarithmique. Autrement dit, le nombre d’opérations est proportionnel au logarithme du nombre d’éléments de la séquence. En outre, l’insertion d’un élément invalide aucun itérateur et supprime un élément invalide uniquement les itérateurs qui pointent vers l’élément supprimé.

Un set itérateur bidirectionnel prend en charge les itérateurs, ce qui signifie que vous pouvez passer à des éléments adjacents en fonction d’un itérateur qui désigne un élément dans la séquence contrôlée. Un nœud principal spécial correspond à l’itérateur retourné par end(). 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 set itérateur pour atteindre le nœud principal, et il est ensuite comparé à end(). Mais vous ne pouvez pas déréférencer l’itérateur retourné par end().

Vous ne pouvez pas faire référence à un set élément directement en fonction de sa position numérique. Cela nécessite un itérateur d’accès aléatoire.

Un set itérateur stocke un handle sur son nœud associé set , qui stocke à son tour un handle dans son conteneur associé. Vous pouvez utiliser des itérateurs uniquement avec leurs objets conteneur associés. Un set itérateur reste valide tant que son nœud associé set est associé à un ensemble. De plus, un itérateur valide est déreferencable. Vous pouvez l’utiliser pour accéder ou modifier la valeur de l’élément qu’elle désigne, tant qu’elle n’est pas égale à end().

L’effacement ou la suppression d’un élément appelle le destructeur pour sa valeur stockée. La destruction du conteneur efface tous les éléments. Ainsi, un conteneur dont le type d’élément est une classe ref garantit qu’aucun élément n’est hors service du conteneur. Toutefois, un conteneur de handles ne détruit pas ses éléments.

Membres

`set::begin`

Désigne le début de la séquence contrôlée.

Syntaxe

iterator begin();

Notes

La fonction membre retourne un itérateur bidirectionnel qui désigne le premier élément de la séquence contrôlée, ou juste au-delà de la fin d’une séquence vide. Vous l’utilisez pour obtenir un itérateur qui désigne le current début de la séquence contrôlée, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_set_begin.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items
    Myset::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

a b c
*begin() = a
*++begin() = b

`set::clear`

Supprime tous les éléments.

Syntaxe

void clear();

Notes

La fonction membre appelle erase(begin(), end())efficacement . Vous l’utilisez pour vous assurer que la séquence contrôlée est vide.

Exemple

// cliext_set_clear.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

// add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

`set::const_iterator`

Type d'un itérateur constant pour la séquence contrôlée.

Syntaxe

typedef T2 const_iterator;

Notes

Le type décrit un objet de type T2 non spécifié qui peut servir d’itérateur bidirectionnel constant pour la séquence contrôlée.

Exemple

// cliext_set_const_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    Myset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::const_reference`

Type d'une référence constante à un élément.

Syntaxe

typedef value_type% const_reference;

Notes

Le type décrit une référence constante à un élément.

Exemple

// cliext_set_const_reference.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    Myset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myset::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::const_reverse_iterator`

Type d'un itérateur inserve constant pour la séquence contrôlée.

Syntaxe

typedef T4 const_reverse_iterator;

Notes

Le type décrit un objet de type T4 non spécifié qui peut servir d’itérateur inverse constant pour la séquence contrôlée.

Exemple

// cliext_set_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" reversed
    Myset::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

`set::count`

Recherche le nombre d’éléments qui correspondent à une clé spécifiée.

Syntaxe

size_type count(key_type key);

Paramètres

key
Valeur de clé à rechercher.

Notes

La fonction membre retourne le nombre d’éléments dans la séquence contrôlée qui ont un ordre équivalent avec key. Vous l’utilisez pour déterminer le nombre d’éléments actuellement dans la séquence contrôlée qui correspondent à une clé spécifiée.

Exemple

// cliext_set_count.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

a b c
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

`set::difference_type`

Types d’une distance signée entre deux éléments.

Syntaxe

typedef int difference_type;

Notes

Le type décrit un nombre d’éléments potentiellement négatif.

Exemple

// cliext_set_difference_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// compute positive difference
    Myset::difference_type diff = 0;
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

// compute negative difference
    diff = 0;
    for (Myset::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

`set::empty`

Vérifie l'absence d'éléments.

Syntaxe

bool empty();

Notes

La fonction membre retourne la valeur true pour une séquence contrôlée vide. Cela équivaut à size() == 0. Vous l’utilisez pour tester si la valeur set est vide.

Exemple

// cliext_set_empty.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

`set::end`

Désigne la fin de la séquence contrôlée.

Syntaxe

iterator end();

Notes

La fonction membre retourne un itérateur bidirectionnel qui pointe juste au-delà de la fin de la séquence contrôlée. Vous l’utilisez pour obtenir un itérateur qui désigne la fin de la séquence contrôlée ; son état ne change pas si la longueur de la séquence contrôlée change.

Exemple

// cliext_set_end.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect last two items
    Myset::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);
    return (0);
    }

a b c
*-- --end() = b
*--end() = c

`set::equal_range`

Recherche une plage qui correspond à une clé spécifiée.

Syntaxe

cliext::pair<iterator, iterator> equal_range(key_type key);

Paramètres

key
Valeur de clé à rechercher.

Notes

La fonction membre retourne une paire d’itérateurs cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Vous l’utilisez pour déterminer la plage d’éléments actuellement dans la séquence contrôlée qui correspond à une clé spécifiée.

Exemple

// cliext_set_equal_range.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
typedef Myset::pair_iter_iter Pairii;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

// display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("{0} ", *pair1.first);
    System::Console::WriteLine();
    return (0);
    }

a b c
equal_range(L'x') empty = True
b

`set::erase`

Supprime les éléments placés aux positions spécifiées.

Syntaxe

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
size_type erase(key_type key)

Paramètres

first
Début de la plage à effacer.

key
Valeur de clé à effacer.

last
Fin de la plage à effacer.

where
Élément à effacer.

Notes

La première fonction membre supprime l’élément de la séquence contrôlée pointée par where, et retourne un itérateur qui désigne le premier élément restant au-delà de l’élément supprimé, ou end() s’il n’existe aucun élément de ce type. Vous l’utilisez pour supprimer un seul élément.

La deuxième fonction membre supprime les éléments de la séquence contrôlée dans la plage [first, last), et retourne un itérateur qui désigne le premier élément restant au-delà des éléments supprimés, ou end() s’il n’existe aucun élément de ce type. Vous l’utilisez pour supprimer zéro ou plusieurs éléments contigus.

La troisième fonction membre supprime tout élément de la séquence contrôlée dont la clé a un ordre équivalent et keyretourne le nombre d’éléments supprimés. Vous l’utilisez pour supprimer et compter tous les éléments qui correspondent à une clé spécifiée.

Chaque effacement d’élément prend du temps proportionnel au logarithme du nombre d’éléments dans la séquence contrôlée.

Exemple

// cliext_set_erase.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

// add elements and display " b c d e"
    c1.insert(L'd');
    c1.insert(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// erase all but end
    Myset::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

`set::find`

Recherche un élément qui correspond à une clé spécifiée.

Syntaxe

iterator find(key_type key);

Paramètres

key
Valeur de clé à rechercher.

Notes

Si au moins un élément de la séquence contrôlée a un ordre équivalent avec key, la fonction membre retourne un itérateur désignant l’un de ces éléments ; sinon, il retourne end(). Vous l’utilisez pour localiser un élément actuellement dans la séquence contrôlée qui correspond à une clé spécifiée.

Exemple

// cliext_set_find.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());
    System::Console::WriteLine("find {0} = {1}",
        L'b', *c1.find(L'b'));
    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

a b c
find A = False
find b = b
find C = False

`set::generic_container`

Type de l’interface générique pour le conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::
    ITree<GKey, GValue>
    generic_container;

Notes

Le type décrit l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_set_generic_container.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    gc1->insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify original and display generic
    c1.insert(L'e');
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

`set::generic_iterator`

Type d’itérateur à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Notes

Le type décrit un itérateur générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_set_generic_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// get an element and display it
    Myset::generic_iterator gcit = gc1->begin();
    Myset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`set::generic_reverse_iterator`

Type d’itérateur inverse à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Notes

Le type décrit un itérateur inverse générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_set_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// get an element and display it
    Myset::generic_reverse_iterator gcit = gc1->rbegin();
    Myset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
c

`set::generic_value`

Type d’un élément à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef GValue generic_value;

Notes

Le type décrit un objet de type GValue qui décrit la valeur de l’élément stocké à utiliser avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_set_generic_value.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// get an element and display it
    Myset::generic_iterator gcit = gc1->begin();
    Myset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`set::insert`

Ajoute des éléments.

Syntaxe

cliext::pair<iterator, bool> insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Paramètres

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Énumération à insérer.

val
Valeur de clé à insérer.

where
Où dans le conteneur insérer (indicateur uniquement).

Notes

Chacune des fonctions membres insère une séquence spécifiée par les opérandes restants.

La première fonction membre s’efforce d’insérer un élément avec la valeur valet retourne une paire de valeurs X. Si X.second la valeur est true, X.first désigne l’élément nouvellement inséré ; sinon X.first , désigne un élément avec un ordre équivalent qui existe déjà et aucun nouvel élément n’est inséré. Vous l’utilisez pour insérer un seul élément.

La deuxième fonction membre insère un élément avec une valeur val, en utilisant where comme indicateur (pour améliorer les performances) et retourne un itérateur qui désigne l’élément nouvellement inséré. Vous l’utilisez pour insérer un élément unique qui peut être à côté d’un élément que vous connaissez.

La troisième fonction membre insère la séquence [first, last). Vous l’utilisez pour insérer zéro ou plusieurs éléments copiés à partir d’une autre séquence.

La quatrième fonction membre insère la séquence désignée par le right. Vous l’utilisez pour insérer une séquence décrite par un énumérateur.

Chaque insertion d’élément prend du temps proportionnelle au logarithme du nombre d’éléments dans la séquence contrôlée. L’insertion peut se produire en temps constant amorti, toutefois, en fonction d’un indicateur qui désigne un élément en regard du point d’insertion.

Exemple

// cliext_set_insert.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
typedef Myset::pair_iter_bool Pairib;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert a single value, unique and duplicate
    Pairib pair1 = c1.insert(L'x');
    System::Console::WriteLine("insert(L'x') = [{0} {1}]",
        *pair1.first, pair1.second);

    pair1 = c1.insert(L'b');
    System::Console::WriteLine("insert(L'b') = [{0} {1}]",
        *pair1.first, pair1.second);

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert a single value with hint
    System::Console::WriteLine("insert(begin(), L'y') = {0}",
        *c1.insert(c1.begin(), L'y'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an iterator range
    Myset c2;
    Myset::iterator it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an enumeration
    Myset c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(L'x') = [x True]
insert(L'b') = [b False]
a b c x
insert(begin(), L'y') = y
a b c x y
a b c x
a b c x y

`set::iterator`

Type d'un itérateur pour la séquence contrôlée.

Syntaxe

typedef T1 iterator;

Notes

Le type décrit un objet de type T1 non spécifié qui peut servir d’itérateur bidirectionnel pour la séquence contrôlée.

Exemple

// cliext_set_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    Myset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::key_comp`

Copie le délégué de classement pour deux clés.

Syntaxe

key_compare^key_comp();

Notes

La fonction membre retourne le délégué de classement utilisé pour commander la séquence contrôlée. Vous l’utilisez pour comparer deux clés.

Exemple

// cliext_set_key_comp.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

// test a different ordering rule
    Myset c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`set::key_compare`

Délégué de classement pour deux clés.

Syntaxe

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Notes

Le type est un synonyme du délégué qui détermine l’ordre de ses arguments clés.

Exemple

// cliext_set_key_compare.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

// test a different ordering rule
    Myset c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`set::key_type`

Type d'une clé de tri.

Syntaxe

typedef Key key_type;

Notes

Le type est un synonyme du paramètre de modèle Key.

Exemple

// cliext_set_key_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" using key_type
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myset::key_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::lower_bound`

Recherche le début de la plage qui correspond à une clé spécifiée.

Syntaxe

iterator lower_bound(key_type key);

Paramètres

key
Valeur de clé à rechercher.

Notes

La fonction membre détermine le premier élément X de la séquence contrôlée qui a l’ordre équivalent à key. Si aucun élément de ce type n’existe, il retourne end(); sinon, il retourne un itérateur qui désigne X. Vous l’utilisez pour localiser le début d’une séquence d’éléments actuellement dans la séquence contrôlée qui correspond à une clé spécifiée.

Exemple

// cliext_set_lower_bound.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    System::Console::WriteLine("*lower_bound(L'a') = {0}",
        *c1.lower_bound(L'a'));
    System::Console::WriteLine("*lower_bound(L'b') = {0}",
        *c1.lower_bound(L'b'));
    return (0);
    }

a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b

`set::make_value`

Construit un objet valeur.

Syntaxe

static value_type make_value(key_type key);

Paramètres

key
Valeur de clé à utiliser.

Notes

La fonction membre retourne un value_type objet dont la clé est key. Vous l’utilisez pour composer un objet adapté à une utilisation avec plusieurs autres fonctions membres.

Exemple

// cliext_set_make_value.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(Myset::make_value(L'a'));
    c1.insert(Myset::make_value(L'b'));
    c1.insert(Myset::make_value(L'c'));

// display contents " a b c"
    for each (Myset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::operator=`

Remplace la séquence contrôlée.

Syntaxe

set<Key>% operator=(set<Key>% right);

Paramètres

right
Conteneur à copier.

Notes

L’opérateur membre copie right dans l’objet, puis retourne *this. Vous l’utilisez pour remplacer la séquence contrôlée par une copie de la séquence contrôlée dans right.

Exemple

// cliext_set_operator_as.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (Myset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2 = c1;
// display contents " a b c"
    for each (Myset::value_type elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

`set::rbegin`

Désigne le début de la séquence contrôlée inverse.

Syntaxe

reverse_iterator rbegin();

Notes

La fonction membre retourne un itérateur inverse qui désigne le dernier élément de la séquence contrôlée, ou juste au-delà du début d’une séquence vide. Par conséquent, il désigne la beginning séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne le current début de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_set_rbegin.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items in reversed sequence
    Myset::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b

`set::reference`

Type d'une référence à un élément.

Syntaxe

typedef value_type% reference;

Notes

Le type décrit une référence à un élément.

Exemple

// cliext_set_reference.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    Myset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myset::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::rend`

Désigne la fin de la séquence contrôlée inverse.

Syntaxe

reverse_iterator rend();

Notes

La fonction membre retourne un itérateur inverse qui pointe juste au-delà du début de la séquence contrôlée. Par conséquent, il désigne la end séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne la current fin de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_set_rend.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items
    Myset::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a

`set::reverse_iterator`

Type d'un itérateur inverse pour la séquence contrôlée.

Syntaxe

typedef T3 reverse_iterator;

Notes

Le type décrit un objet de type T3 non spécifié qui peut servir d’itérateur inverse pour la séquence contrôlée.

Exemple

// cliext_set_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" reversed
    Myset::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a

`set::set`

Construit un objet conteneur.

Syntaxe

set();
explicit set(key_compare^ pred);
set(set<Key>% right);
set(set<Key>^ right);
template<typename InIter>
    setset(InIter first, InIter last);
template<typename InIter>
    set(InIter first, InIter last,
        key_compare^ pred);
set(System::Collections::Generic::IEnumerable<GValue>^ right);
set(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);

Paramètres

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

pred
Classement du prédicat pour la séquence contrôlée.

right
Objet ou plage à insérer.

Notes

Constructeur :

set();

initialise la séquence contrôlée sans éléments, avec le prédicat key_compare()de classement par défaut. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide, avec le prédicat de classement par défaut.

Constructeur :

explicit set(key_compare^ pred);

initialise la séquence contrôlée sans éléments, avec le prédicat predde classement . Vous l’utilisez pour spécifier une séquence contrôlée initiale vide, avec le prédicat de classement spécifié.

Constructeur :

set(set<Key>% right);

initialise la séquence contrôlée avec la séquence [right.begin(), right.end()), avec le prédicat de classement par défaut. Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet set right, avec le prédicat de classement par défaut.

Constructeur :

set(set<Key>^ right);

initialise la séquence contrôlée avec la séquence [right->begin(), right->end()), avec le prédicat de classement par défaut. Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet set right, avec le prédicat de classement par défaut.

Constructeur :

template<typename InIter> set(InIter first, InIter last);

initialise la séquence contrôlée avec la séquence [first, last), avec le prédicat de classement par défaut. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence, avec le prédicat de classement par défaut.

Constructeur :

template<typename InIter> set(InIter first, InIter last, key_compare^ pred);

initialise la séquence contrôlée avec la séquence [first, last), avec le prédicat predde classement . Vous l’utilisez pour faire de la séquence contrôlée une copie d’une autre séquence, avec le prédicat de classement spécifié.

Constructeur :

set(System::Collections::Generic::IEnumerable<Key>^ right);

initialise la séquence contrôlée avec la séquence désignée par l’énumérateur right, avec le prédicat de classement par défaut. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence décrite par un énumérateur, avec le prédicat de classement par défaut.

Constructeur :

set(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

initialise la séquence contrôlée avec la séquence désignée par l’énumérateur right, avec le prédicat predde classement . Vous l’utilisez pour faire de la séquence contrôlée une copie d’une autre séquence décrite par un énumérateur, avec le prédicat de classement spécifié.

Exemple

// cliext_set_construct.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
// construct an empty container
    Myset c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an ordering rule
    Myset c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an iterator range
    Myset c3(c1.begin(), c1.end());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an iterator range and an ordering rule
    Myset c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an enumeration
    Myset c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an enumeration and an ordering rule
    Myset c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c6)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct from a generic container
    Myset c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying another container
    Myset c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
a b c
size() = 0
c b a
a b c
c b a
a b c
c b a
c b a
a b c

`set::size`

Compte le nombre d'éléments.

Syntaxe

size_type size();

Notes

La fonction membre retourne la longueur de la séquence contrôlée. Vous l’utilisez pour déterminer le nombre d’éléments actuellement dans la séquence contrôlée. Si tout ce dont vous vous souciez est de savoir si la séquence a une taille différente de zéro, voir empty().

Exemple

// cliext_set_size.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

// clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

// add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

`set::size_type`

Type d'une distance signée entre deux éléments.

Syntaxe

typedef int size_type;

Notes

Le type décrit un nombre d’éléments non négatifs.

Exemple

// cliext_set_size_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// compute positive difference
    Myset::size_type diff = 0;
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

`set::swap`

Échange le contenu de deux conteneurs.

Syntaxe

void swap(set<Key>% right);

Paramètres

right
Conteneur avec lequel échanger le contenu.

Notes

La fonction membre échange les séquences contrôlées entre this et right. Il le fait en temps constant et ne lève aucune exception. Vous l’utilisez comme moyen rapide d’échanger le contenu de deux conteneurs.

Exemple

// cliext_set_swap.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct another container with repetition of values
    Myset c2;
    c2.insert(L'd');
    c2.insert(L'e');
    c2.insert(L'f');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
d e f
d e f
a b c

`set::to_array`

Copie la séquence contrôlée dans un nouveau tableau.

Syntaxe

cli::array<value_type>^ to_array();

Notes

La fonction membre retourne un tableau contenant la séquence contrôlée. Vous l’utilisez pour obtenir une copie de la séquence contrôlée sous forme de tableau.

Exemple

// cliext_set_to_array.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

`set::upper_bound`

Recherche la fin de la plage qui correspond à une clé spécifiée.

Syntaxe

iterator upper_bound(key_type key);

Paramètres

key
Valeur de clé à rechercher.

Notes

La fonction membre détermine le dernier élément X de la séquence contrôlée qui a un ordre équivalent à key. S’il n’existe aucun élément de ce type ou s’il X s’agit du dernier élément de la séquence contrôlée, il retourne end(); sinon, il retourne un itérateur qui désigne le premier élément au-delà Xde . Vous l’utilisez pour localiser la fin d’une séquence d’éléments actuellement dans la séquence contrôlée qui correspond à une clé spécifiée.

Exemple

// cliext_set_upper_bound.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    System::Console::WriteLine("*upper_bound(L'a') = {0}",
        *c1.upper_bound(L'a'));
    System::Console::WriteLine("*upper_bound(L'b') = {0}",
        *c1.upper_bound(L'b'));
    return (0);
    }

a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c

`set::value_comp`

Copie le délégué de classement pour deux valeurs d’élément.

Syntaxe

value_compare^ value_comp();

Notes

La fonction membre retourne le délégué de classement utilisé pour commander la séquence contrôlée. Vous l’utilisez pour comparer deux valeurs d’élément.

Exemple

// cliext_set_value_comp.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`set::value_compare`

Délégué de classement pour deux valeurs d’élément.

Syntaxe

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Notes

Le type est un synonyme du délégué qui détermine l’ordre de ses arguments de valeur.

Exemple

// cliext_set_value_compare.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`set::value_type`

Type d’un élément.

Syntaxe

typedef generic_value value_type;

Notes

Le type est un synonyme de generic_value.

Exemple

// cliext_set_value_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" using value_type
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myset::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`operator!=` (set)

Lister les comparaisons non égales.

Syntaxe

template<typename Key>
    bool operator!=(set<Key>% left,
        set<Key>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(left == right). Vous l’utilisez pour tester si left l’élément n’est pas classé de la même façon que right lorsque les deux jeux sont comparés par élément.

Exemple

// cliext_set_operator_ne.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

`operator<` (set)

Liste inférieure à la comparaison.

Syntaxe

template<typename Key>
    bool operator<(set<Key>% left,
        set<Key>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne true si, pour la position i la plus basse pour laquelle !(right[i] < left[i]) elle est également vraie.left[i] < right[i] Sinon, left->size() < right->size()est retourné. Vous l’utilisez pour tester s’il left est ordonné avant right que les deux jeux soient comparés par élément.

Exemple

// cliext_set_operator_lt.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (set)

Liste inférieure ou égale à la comparaison.

Syntaxe

template<typename Key>
    bool operator<=(set<Key>% left,
        set<Key>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(right < left). Vous l’utilisez pour tester s’il left n’est pas ordonné après right le moment où les deux jeux sont comparés par élément.

Exemple

// cliext_set_operator_le.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

`operator==` (set)

Lister la comparaison égale.

Syntaxe

template<typename Key>
    bool operator==(set<Key>% left,
        set<Key>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction opérateur retourne true uniquement si les séquences contrôlées par left et right ont la même longueur et, pour chaque position i, left[i] == right[i]. Vous l’utilisez pour tester si left l’ordre est le même que right lorsque les deux jeux sont comparés par élément.

Exemple

// cliext_set_operator_eq.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (set)

Liste supérieure à la comparaison.

Syntaxe

template<typename Key>
    bool operator>(set<Key>% left,
        set<Key>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne right < left. Vous l’utilisez pour tester s’il left est ordonné après right le moment où les deux jeux sont comparés par élément.

Exemple

// cliext_set_operator_gt.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (set)

Liste supérieure ou égale à la comparaison.

Syntaxe

template<typename Key>
    bool operator>=(set<Key>% left,
        set<Key>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(left < right). Vous l’utilisez pour tester s’il left n’est pas ordonné avant right que les deux jeux soient comparés par élément.

Exemple

// cliext_set_operator_ge.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False

Partager via

set (STL/CLR)

Syntaxe

Paramètres

Spécifications

Déclarations

Interfaces

Notes

Membres

set::begin

Syntaxe

Notes

Exemple

set::clear

Syntaxe

Notes

Exemple

set::const_iterator

Syntaxe

Notes

Exemple

set::const_reference

Syntaxe

Notes

Exemple

set::const_reverse_iterator

Syntaxe

Notes

Exemple

set::count

Syntaxe

Paramètres

Notes

Exemple

set::difference_type

Syntaxe

Notes

Exemple

set::empty

Syntaxe

Notes

Exemple

set::end

Syntaxe

Notes

Exemple

set::equal_range

Syntaxe

Paramètres

Notes

Exemple

set::erase

Syntaxe

Paramètres

Notes

Exemple

set::find

Syntaxe

Paramètres

Notes

Exemple

set::generic_container

Syntaxe

Notes

Exemple

set::generic_iterator

Syntaxe

Notes

Exemple

set::generic_reverse_iterator

Syntaxe

Notes

Exemple

set::generic_value

Syntaxe

Notes

Exemple

set::insert

Syntaxe

Paramètres

`set` (STL/CLR)

`set::begin`

`set::clear`

`set::const_iterator`

`set::const_reference`

`set::const_reverse_iterator`

`set::count`

`set::difference_type`

`set::empty`

`set::end`

`set::equal_range`

`set::erase`

`set::find`

`set::generic_container`

`set::generic_iterator`

`set::generic_reverse_iterator`

`set::generic_value`

`set::insert`

`set::iterator`

`set::key_comp`

`set::key_compare`

`set::key_type`

`set::lower_bound`

`set::make_value`

`set::operator=`

`set::rbegin`

`set::reference`

`set::rend`

`set::reverse_iterator`

`set::set`

`set::size`

`set::size_type`

`set::swap`

`set::to_array`