hash_set::hash_set (STL/CLR)

Article
06/07/2013

Construit un objet.

    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

tout d'abord
Début de la plage à insérer.
hashfn
Fonction de hachage pour mapper des clés dans des compartiments restant.
last
Fin de la plage à insérer.
pred
Classer l'attribut pour la séquence contrôlée.
right
Objet ou plage à ajouter.

Notes

Le constructeur :

hash_set();

initialise la séquence contrôlée sans éléments, avec l'attribut classant par défaut key_compare(), et avec la fonction de hachage par défaut.Vous l'utilisez pour spécifier une séquence contrôlée par initiale vide, avec l'attribut et la fonction de hachage classants par défaut.

Le constructeur :

explicit hash_set(key_compare^ pred);

initialise la séquence contrôlée sans éléments, avec l'attribut classement pred, et avec la fonction de hachage par défaut.Vous l'utilisez pour spécifier une séquence contrôlée par initiale vide, avec l'attribut classement spécifié et la fonction de hachage par défaut.

Le constructeur :

hash_set(key_compare^ pred, hasher^ hashfn);

initialise la séquence contrôlée sans éléments, avec l'attribut classement pred, et avec la fonction de hachage hashfn.Vous l'utilisez pour spécifier une séquence contrôlée par initiale vide, avec l'attribut et la fonction de hachage classants spécifiés.

Le constructeur :

hash_set(hash_set<Key>% right);

initialise la séquence contrôlée avec la séquence [right.hash_set::begin (STL/CLR)(),right.hash_set::end (STL/CLR)()), avec l'attribut classant par défaut, et avec la fonction de hachage par défaut.Vous l'utilisez pour spécifier une séquence contrôlée par défaut qui est une copie de la séquence contrôlée par l'objet rightde hash_set, avec l'attribut et la fonction de hachage classants par défaut.

Le constructeur :

hash_set(hash_set<Key>^ right);

initialise la séquence contrôlée avec la séquence [right->hash_set::begin (STL/CLR)(),right->hash_set::end (STL/CLR)()), avec l'attribut classant par défaut, et avec la fonction de hachage par défaut.Vous l'utilisez pour spécifier une séquence contrôlée par défaut qui est une copie de la séquence contrôlée par l'objet rightde hash_set, avec l'attribut et la fonction de hachage classants par défaut.

Le constructeur :

template<typename InIter>

hash_set(InIter first, InIter last);

initialise la séquence contrôlée avec la séquence [first,last), avec l'attribut classant par défaut, et avec la fonction de hachage par défaut.Vous l'utilisez pour tirer à la séquence est contrôlée par une copie d'une autre séquence, avec l'attribut et la fonction de hachage classants par défaut.

Le 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 l'attribut classement pred, et avec la fonction de hachage par défaut.Vous l'utilisez pour tirer à la séquence est contrôlée par une copie d'une autre séquence, avec l'attribut classement spécifié et la fonction de hachage par défaut.

Le 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 l'attribut classement pred, et avec la fonction de hachage hashfn.Vous l'utilisez pour tirer à la séquence est contrôlée par une copie d'une autre séquence, avec l'attribut et la fonction de hachage classants spécifiés.

Le constructeur :

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

initialise la séquence contrôlée avec la séquence indiquée par l'énumérateur right, avec l'attribut classant par défaut, et avec la fonction de hachage par défaut.Vous l'utilisez pour tirer à la séquence est contrôlée par une copie d'une autre séquence décrite par un énumérateur, avec l'attribut et la fonction de hachage classants par défaut.

Le constructeur :

hash_set(System::Collections::Generic::IEnumerable<Key>^ right,

key_compare^ pred);

initialise la séquence contrôlée avec la séquence indiquée par l'énumérateur right, avec l'attribut classement pred, et avec la fonction de hachage par défaut.Vous l'utilisez pour tirer à la séquence est contrôlée par une copie d'une autre séquence décrite par un énumérateur, avec l'attribut et la fonction de hachage classants spécifiés par défaut.

Le 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 indiquée par l'énumérateur right, avec l'attribut classement pred, et avec la fonction de hachage hashfn.Vous l'utilisez pour tirer à la séquence est contrôlée par une copie d'une autre séquence décrite par un énumérateur, avec l'attribut et la fonction de hachage classants 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); 
    }