`hash_set` (STL/CLR)

Article
04/03/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 hash_set pour gérer une séquence d’éléments en tant que table de hachage, chaque entrée de table stockant une liste liée bidirectionnelle de nœuds et chaque nœud stockant un élément. La valeur de chaque élément est utilisée comme clé pour classer la séquence.

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 hash_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::IHash<Gkey, GValue>
    { ..... };

Paramètres

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

Spécifications

Header :<cliext/hash_set>

Espace de noms :cliext

Déclarations

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

Fonction membre	Description
`hash_set::begin`	Désigne le début de la séquence contrôlée.
`hash_set::bucket_count`	Compte le nombre de compartiments.
`hash_set::clear`	Supprime tous les éléments.
`hash_set::count`	Compte les éléments correspondant à une clé spécifiée.
`hash_set::empty`	Vérifie l'absence d'éléments.
`hash_set::end`	Désigne la fin de la séquence contrôlée.
`hash_set::equal_range`	Recherche une plage qui correspond à une clé spécifiée.
`hash_set::erase`	Supprime les éléments placés aux positions spécifiées.
`hash_set::find`	Recherche un élément qui correspond à une clé spécifiée.
`hash_set::hash_delegate`	Copie le délégué de hachage pour une clé.
`hash_set::hash_set`	Construit un objet conteneur.
`hash_set::insert`	Ajoute des éléments.
`hash_set::key_comp`	Copie le délégué de classement pour deux clés.
`hash_set::load_factor`	Compte le nombre moyen d'éléments par compartiment.
`hash_set::lower_bound`	Recherche le début de la plage qui correspond à une clé spécifiée.
`hash_set::make_value`	Construit un objet valeur.
`hash_set::max_load_factor`	Obtient ou définit le nombre maximal d’éléments par compartiment.
`hash_set::rbegin`	Désigne le début de la séquence contrôlée inverse.
`hash_set::rehash`	Régénère la table de hachage.
`hash_set::rend`	Désigne la fin de la séquence contrôlée inverse.
`hash_set::size`	Compte le nombre d'éléments.
`hash_set::swap`	Échange le contenu de deux conteneurs.
`hash_set::to_array`	Copie la séquence contrôlée dans un nouveau tableau.
`hash_set::upper_bound`	Recherche la fin de la plage qui correspond à une clé spécifiée.
`hash_set::value_comp`	Copie le délégué de classement pour deux valeurs d’élément.

Opérateur	Description
`hash_set::operator=`	Remplace la séquence contrôlée.

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.
`IHash<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 dans une liste liée bidirectionnelle. Pour accélérer l’accès, l’objet conserve également un tableau de pointeurs de longueur variable dans la liste (la table de hachage), gérant efficacement l’ensemble de la liste sous la forme d’une séquence de sous-listes ou de compartiments. Il insère des éléments dans un compartiment qu’il conserve ordonné 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 chaque compartiment qu’il contrôle en appelant un objet délégué stocké de type hash_set::key_compare. 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 comparaison operator<=(key_type, key_type).

Vous accédez à l’objet délégué stocké en appelant la fonction hash_set::key_compmembre. Un tel objet délégué doit définir un ordre équivalent entre les clés de type hash_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) && key_comp()(Y, X) c’est vrai, alors X et Y sont dits avoir un ordre é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 l’ordre équivalent.

Le conteneur garantit uniquement que les éléments dont les clés ont un ordre équivalent (et qui se hachage à la même valeur entière) sont adjacents dans un compartiment. Contrairement à la classe de modèle hash_multiset (STL/CLR), un objet de classe hash_set de modèle garantit que les clés pour tous les éléments sont uniques. (Aucune deux clés n’ont un ordre équivalent.)

L’objet détermine quel compartiment doit contenir une clé de classement donnée en appelant un objet délégué stocké de type hash_set::hasher. Vous accédez à cet objet stocké en appelant la fonction hash_set::hash_delegate membre 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 spécifiez aucun objet délégué, la valeur par défaut est la fonction System::Object::hash_value(key_type). Cela signifie que, pour toutes les clés X et Y:

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

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

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 en temps constant. Autrement dit, le nombre d’opérations est indépendant du nombre d’éléments de la séquence, au moins dans les meilleurs cas. 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é.

Si les valeurs hachées ne sont pas distribuées uniformément, toutefois, une table de hachage peut 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 de la séquence (temps linéaire). Le conteneur s’efforce de choisir une fonction de hachage raisonnable, une taille moyenne de compartiment et une taille de table de hachage (nombre total de compartiments), mais vous pouvez remplacer n’importe quel ou tous ces choix. Voir, par exemple, les fonctions hash_set::max_load_factor et hash_set::rehash.

Un hash_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 hash_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 hash_set élément directement en fonction de sa position numérique. Cela nécessite un itérateur d’accès aléatoire.

Un hash_set itérateur stocke un handle sur son nœud associé hash_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 hash_set itérateur reste valide tant que son nœud associé hash_set est associé à un certain hash_set. 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

`hash_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_hash_set_begin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

`hash_set::bucket_count`

Compte le nombre de compartiments.

Syntaxe

int bucket_count();

Notes

La fonction membre retourne le nombre actuel de comportements. Vous l’utilisez pour déterminer la taille de la table de hachage.

Exemple

// cliext_hash_set_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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 current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

`hash_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_hash_set_clear.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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

`hash_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_hash_set_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

a b c

`hash_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_hash_set_const_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

a b c

`hash_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_hash_set_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

c b a

`hash_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_hash_set_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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

`hash_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_hash_set_difference_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::difference_type diff = 0;
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Myhash_set::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

`hash_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 hash_set est vide.

Exemple

// cliext_hash_set_empty.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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

`hash_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_hash_set_end.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::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

`hash_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_hash_set_equal_range.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
typedef Myhash_set::pair_iter_iter Pairii;
int main()
    {
    Myhash_set 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

`hash_set::erase`

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

Syntaxe

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool 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_hash_set_erase.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::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

`hash_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_hash_set_find.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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

`hash_set::generic_container`

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

Syntaxe

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

Notes

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

Exemple

// cliext_hash_set_generic_container.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::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

`hash_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_hash_set_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::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
    Myhash_set::generic_iterator gcit = gc1->begin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`hash_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_hash_set_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::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
    Myhash_set::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
c

`hash_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_hash_set_generic_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::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
    Myhash_set::generic_iterator gcit = gc1->begin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`hash_set::hash_delegate`

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

Syntaxe

hasher^ hash_delegate();

Notes

La fonction membre retourne le délégué utilisé pour convertir une valeur de clé en entier. Vous l’utilisez pour hacher une clé.

Exemple

// cliext_hash_set_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::hasher^ myhash = c1.hash_delegate();

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

hash(L'a') = 1616896120
hash(L'b') = 570892832

`hash_set::hash_set`

Construit un objet conteneur.

Syntaxe

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

Paramètres

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

hashfn
Fonction de hachage pour le mappage des clés aux compartiments.

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 :

hash_set();

initialise la séquence contrôlée sans éléments, avec le prédicat key_compare()de classement par défaut et la fonction de hachage 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 et la fonction de hachage.

Constructeur :

explicit hash_set(key_compare^ pred);

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

Constructeur :

hash_set(key_compare^ pred, hasher^ hashfn);

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

Constructeur :

hash_set(hash_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 et avec la fonction de hachage 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 hash_setright, avec le prédicat de classement par défaut et la fonction de hachage.

Constructeur :

hash_set(hash_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 et avec la fonction de hachage 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 hash_setright, avec le prédicat de classement par défaut et la fonction de hachage.

Constructeur :

template<typename InIter> hash_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 et avec la fonction de hachage 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 et la fonction de hachage.

Constructeur :

template<typename InIter> hash_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 et avec la fonction de hachage 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 spécifié et la fonction de hachage par défaut.

Constructeur :

template<typename InIter> hash_set(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

initialise la séquence contrôlée avec la séquence [first, last), avec le prédicat predde classement et avec la fonction hashfnde hachage . 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 et la fonction de hachage spécifiés.

Constructeur :

hash_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 et avec la fonction de hachage 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 et la fonction de hachage.

Constructeur :

hash_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 et avec la fonction de hachage 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 spécifié et la fonction de hachage par défaut.

Constructeur :

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

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 et avec la fonction hashfnde hachage . 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 et la fonction de hachage spécifiés.

Exemple

// cliext_hash_set_construct.cpp
// compile with: /clr
#include <cliext/hash_set>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
// construct an empty container
    Myhash_set 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
    Myhash_set 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 ordering rule and hash function
    Myhash_set c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_set::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

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

    // construct with an iterator range
    Myhash_set 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
    Myhash_set 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 iterator range and an ordering rule and hash function
    Myhash_set c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_set::hasher(&myfun));
    for each (wchar_t elem in c4h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an enumeration
    Myhash_set 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
    Myhash_set 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 with an enumeration and an ordering rule and hash function
    Myhash_set c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>(),
                gcnew Myhash_set::hasher(&myfun));
    for each (wchar_t elem in c6h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

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

    // construct by copying another container
    Myhash_set 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
a b c
size() = 0
c b a

a b c
a b c
c b a

a b c
a b c
c b a

a b c
a b c

`hash_set::hasher`

Délégué de hachage pour une clé.

Syntaxe

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

Notes

Le type décrit un délégué qui convertit une valeur de clé en entier.

Exemple

// cliext_hash_set_hasher.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::hasher^ myhash = c1.hash_delegate();

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

hash(L'a') = 1616896120
hash(L'b') = 570892832

`hash_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_hash_set_insert.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
typedef Myhash_set::pair_iter_bool Pairib;
int main()
    {
    Myhash_set 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
    Myhash_set c2;
    Myhash_set::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
    Myhash_set 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

`hash_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_hash_set_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

a b c

`hash_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_hash_set_key_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::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
    Myhash_set 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') = True
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

`hash_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_hash_set_key_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::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
    Myhash_set 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') = True
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

`hash_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_hash_set_key_type.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

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

a b c

`hash_set::load_factor`

Compte le nombre moyen d'éléments par compartiment.

Syntaxe

float load_factor();

Notes

La fonction membre retourne (float)size() / bucket_count(). Vous l’utilisez pour déterminer la taille moyenne du compartiment.

Exemple

// cliext_hash_set_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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 current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

`hash_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 hachage dans le même compartiment que key et a un 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_hash_set_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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

`hash_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_hash_set_make_value.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

a b c

`hash_set::max_load_factor`

Obtient ou définit le nombre maximal d’éléments par compartiment.

Syntaxe

float max_load_factor();
void max_load_factor(float new_factor);

Paramètres

new_factor
Nouveau facteur de charge maximal à stocker.

Notes

La première fonction membre retourne le facteur de charge maximal stocké actuel. Vous l’utilisez pour déterminer la taille moyenne maximale du compartiment.

La deuxième fonction membre remplace le facteur de charge maximal du magasin par new_factor. Aucun réachage automatique n’a lieu tant qu’une insertion ultérieure n’a pas lieu.

Exemple

// cliext_hash_set_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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 current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

`hash_set::operator=`

Remplace la séquence contrôlée.

Syntaxe

hash_set<Key>% operator=(hash_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_hash_set_operator_as.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

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

a b c
a b c

`hash_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_hash_set_rbegin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::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

`hash_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_hash_set_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

a b c

`hash_set::rehash`

Régénère la table de hachage.

Syntaxe

void rehash();

Notes

La fonction membre reconstruit la table de hachage, en veillant à ce que load_factor() <= max_load_factor(). Sinon, la table de hachage augmente uniquement si nécessaire après une insertion. (Il ne diminue jamais automatiquement la taille.) Vous l’utilisez pour ajuster la taille de la table de hachage.

Exemple

// cliext_hash_set_rehash.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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 current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

`hash_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_hash_set_rend.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::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

`hash_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_hash_set_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

c b a

`hash_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_hash_set_size.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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

`hash_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_hash_set_size_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set::size_type diff = 0;
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

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

`hash_set::swap`

Échange le contenu de deux conteneurs.

Syntaxe

void swap(hash_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_hash_set_swap.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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
    Myhash_set 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

`hash_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_hash_set_to_array.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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

`hash_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 hachage dans le même compartiment que key et 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_hash_set_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set 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

`hash_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_hash_set_value_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::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') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`hash_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_hash_set_value_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::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') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`hash_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_hash_set_value_type.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

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

a b c

hash_set (STL/CLR)

Syntaxe

Paramètres

Spécifications

Déclarations

Interfaces

Notes

Membres

hash_set::begin

Syntaxe

Notes

Exemple

hash_set::bucket_count

Syntaxe

Notes

Exemple

hash_set::clear

Syntaxe

Notes

Exemple

hash_set::const_iterator

Syntaxe

Notes

Exemple

hash_set::const_reference

Syntaxe

Notes

Exemple

hash_set::const_reverse_iterator

Syntaxe

Notes

Exemple

hash_set::count

Syntaxe

Paramètres

Notes

Exemple

hash_set::difference_type

Syntaxe

Notes

Exemple

hash_set::empty

Syntaxe

Notes

Exemple

hash_set::end

Syntaxe

Notes

Exemple

hash_set::equal_range

Syntaxe

Paramètres

Notes

Exemple

hash_set::erase

Syntaxe

Paramètres

Notes

Exemple

hash_set::find

Syntaxe

Paramètres

Notes

Exemple

hash_set::generic_container

Syntaxe

Notes

Exemple

hash_set::generic_iterator

Syntaxe

Notes

Exemple

hash_set::generic_reverse_iterator

Syntaxe

Notes

Exemple

hash_set::generic_value

Syntaxe

Notes

Exemple

`hash_set` (STL/CLR)

`hash_set::begin`

`hash_set::bucket_count`

`hash_set::clear`

`hash_set::const_iterator`

`hash_set::const_reference`

`hash_set::const_reverse_iterator`

`hash_set::count`

`hash_set::difference_type`

`hash_set::empty`

`hash_set::end`

`hash_set::equal_range`

`hash_set::erase`

`hash_set::find`

`hash_set::generic_container`

`hash_set::generic_iterator`

`hash_set::generic_reverse_iterator`

`hash_set::generic_value`

`hash_set::hash_delegate`

`hash_set::hash_set`

`hash_set::hasher`

`hash_set::insert`

`hash_set::iterator`

`hash_set::key_comp`

`hash_set::key_compare`

`hash_set::key_type`

`hash_set::load_factor`

`hash_set::lower_bound`

`hash_set::make_value`

`hash_set::max_load_factor`

`hash_set::operator=`

`hash_set::rbegin`

`hash_set::reference`

`hash_set::rehash`