hash_set (STL/CLR)

Klasa szablonu opisuje obiekt, który kontroluje różną długość sekwencji elementów, które mają dostęp dwukierunkowy. Kontener hash_set służy do zarządzania sekwencją elementów jako tabeli skrótów, każdy wpis tabeli przechowujący dwukierunkową listę połączonych węzłów i każdy węzeł przechowujący jeden element. Wartość każdego elementu jest używana jako klucz do porządkowania sekwencji.

W poniższym GValue opisie parametr jest taki sam jak , który z kolei jest taki sam, GKeyjak Key w przypadku, gdy ten ostatni jest typem ref, w takim przypadku jest Key^to .

Składnia

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>
    { ..... };

Parametry

Key
Typ kluczowego składnika elementu w kontrolowanej sekwencji.

Wymagania

Header:<cliext/hash_set>

Przestrzeń nazw: cliext

Deklaracje

Definicja typu	opis
hash_set::const_iterator	Typ iteratora stałego dla kontrolowanej sekwencji.
hash_set::const_reference	Typ stałego odwołania do elementu.
hash_set::const_reverse_iterator	Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.
hash_set::difference_type	Typ (ewentualnie podpisanej) odległości między dwoma elementami.
hash_set::generic_container	Typ interfejsu ogólnego dla kontenera.
hash_set::generic_iterator	Typ iteratora dla interfejsu ogólnego dla kontenera.
hash_set::generic_reverse_iterator	Typ iteratora odwrotnego dla interfejsu ogólnego dla kontenera.
hash_set::generic_value	Typ elementu dla interfejsu ogólnego kontenera.
hash_set::hasher	Delegat skrótu dla klucza.
hash_set::iterator	Typ iteratora dla kontrolowanej sekwencji.
hash_set::key_compare	Delegat porządkowania dla dwóch kluczy.
hash_set::key_type	Typ klucza sortowania.
hash_set::reference	Typ odwołania do elementu.
hash_set::reverse_iterator	Typ iteratora odwrotnego dla kontrolowanej sekwencji.
hash_set::size_type	Typ odległości (nieujemnej) między dwoma elementami.
hash_set::value_compare	Delegat porządkowania dla dwóch wartości elementów.
hash_set::value_type	Typ elementu.

Funkcja składowa	opis
hash_set::begin	Określa początek kontrolowanej sekwencji.
hash_set::bucket_count	Zlicza liczbę zasobników.
hash_set::clear	Usuwa wszystkie elementy.
hash_set::count	Zlicza elementy pasujące do określonego klucza.
hash_set::empty	Sprawdza, czy nie ma żadnych elementów.
hash_set::end	Określa koniec kontrolowanej sekwencji.
hash_set::equal_range	Wyszukuje zakres, który odpowiada określonemu kluczowi.
hash_set::erase	Usuwa elementy z określonych pozycji.
hash_set::find	Wyszukuje element, który odpowiada określonemu kluczowi.
hash_set::hash_delegate	Kopiuje delegata tworzenia skrótów dla klucza.
hash_set::hash_set	Konstruuje obiekt kontenera.
hash_set::insert	Dodaje elementy.
hash_set::key_comp	Kopiuje delegata porządkowania dla dwóch kluczy.
hash_set::load_factor	Oblicza średnią liczbę elementów na przedział.
hash_set::lower_bound	Znajduje początek zakresu, który pasuje do określonego klucza.
hash_set::make_value	Tworzy obiekt wartości.
hash_set::max_load_factor	Pobiera lub ustawia maksymalną liczbę elementów na przedział.
hash_set::rbegin	Wyznacza początek odwróconej kontrolowanej sekwencji.
hash_set::rehash	Przebudowuje tabelę mieszania.
hash_set::rend	Wyznacza koniec odwróconej kontrolowanej sekwencji.
hash_set::size	Liczy liczbę elementów.
hash_set::swap	Zamienia zawartości dwóch kontenerów.
hash_set::to_array	Kopiuje kontrolowaną sekwencję do nowej tablicy.
hash_set::upper_bound	Znajduje koniec zakresu, który pasuje do określonego klucza.
hash_set::value_comp	Kopiuje delegata porządkowania dla dwóch wartości elementów.

Operator	opis
hash_set::operator=	Zastępuje kontrolowaną sekwencję.

Interfejsy

Interfejs	opis
ICloneable	Duplikuj obiekt.
IEnumerable	Sekwencja elementów.
ICollection	Zachowaj grupę elementów.
IEnumerable<T>	Sekwencjonowanie przez wpisane elementy.
ICollection<T>	Zachowaj grupę wpisanych elementów.
IHash<Key, Value>	Obsługa ogólnego kontenera.

Uwagi

Obiekt przydziela i zwalnia magazyn dla sekwencji, która kontroluje jako poszczególne węzły na liście połączonej dwukierunkowej. Aby przyspieszyć dostęp, obiekt utrzymuje również tablicę wskaźników o różnej długości do listy (tabela skrótów), skutecznie zarządzając całą listą jako sekwencją podlist lub zasobników. Wstawia elementy do zasobnika, który jest uporządkowany przez zmianę łączy między węzłami, nigdy przez skopiowanie zawartości jednego węzła do innego. Oznacza to, że można swobodnie wstawiać i usuwać elementy bez zakłócania pozostałych elementów.

Obiekt porządkuje każdy zasobnik, który kontroluje, wywołując przechowywany obiekt delegata typu hash_set::key_compare. Przechowywany obiekt delegata można określić podczas konstruowania hash_set; Jeśli nie określisz obiektu delegata, wartością domyślną jest porównanie operator<=(key_type, key_type).

Dostęp do przechowywanego obiektu delegata jest wywoływany przez wywołanie funkcji hash_set::key_compskładowej . Taki obiekt delegata musi definiować równoważną kolejność między kluczami typu hash_set::key_type. Oznacza to, że dla dwóch kluczy X i Y:

key_comp()(X, Y) Zwraca ten sam wynik logiczny dla każdego wywołania.

Jeśli key_comp()(X, Y) && key_comp()(Y, X) to prawda, to X i Y mówi się, że mają równoważne kolejność.

Każda reguła porządkowania, która zachowuje się jak operator<=(key_type, key_type), operator>=(key_type, key_type) lub operator==(key_type, key_type) definiuje równoważną kolejność.

Kontener zapewnia, że tylko elementy, których klucze mają równoważne kolejność (i które skróty do tej samej wartości całkowitej) sąsiadują w zasobniku. W przeciwieństwie do klasy szablonu hash_multiset (STL/CLR) obiekt klasy hash_set szablonu gwarantuje, że klucze dla wszystkich elementów są unikatowe. (Żadne dwa klucze nie mają równoważnej kolejności).

Obiekt określa, który zasobnik powinien zawierać określony klucz porządkowania, wywołując przechowywany obiekt delegata typu hash_set::hasher. Uzyskujesz dostęp do tego przechowywanego obiektu przez wywołanie funkcji hash_set::hash_delegate składowej w celu uzyskania wartości całkowitej, która zależy od wartości klucza. Przechowywany obiekt delegata można określić podczas konstruowania hash_set; Jeśli nie określisz obiektu delegata, wartość domyślna to funkcja System::Object::hash_value(key_type). Oznacza to, że dla wszystkich kluczy X i Y:

hash_delegate()(X) Zwraca ten sam wynik liczby całkowitej dla każdego wywołania.

Jeśli X i Y mają równoważną kolejność, hash_delegate()(X) należy zwrócić ten sam wynik liczby całkowitej co hash_delegate()(Y).

Każdy element służy zarówno jako klucz, jak i wartość. Sekwencja jest reprezentowana w sposób, który umożliwia wyszukiwanie, wstawianie i usuwanie dowolnego elementu w stałym czasie. Oznacza to, że liczba operacji jest niezależna od liczby elementów w sekwencji, przynajmniej w najlepszych przypadkach. Ponadto wstawienie elementu powoduje unieważnienie żadnych iteratorów i usunięcie elementu unieważnia tylko te iteratory wskazujące na usunięty element.

Jeśli jednak wartości skrótów nie są równomiernie rozłożone, tabela skrótów może się degenerować. W skrajności (w przypadku funkcji skrótu, która zawsze zwraca tę samą wartość), wyszukiwanie, wstawianie i usuwanie są proporcjonalne do liczby elementów w sekwencji (czas liniowy). Kontener stara się wybrać rozsądną funkcję skrótu, średni rozmiar zasobnika i rozmiar tabeli skrótów (łączna liczba zasobników), ale można zastąpić dowolną lub wszystkie te opcje. Zobacz na przykład funkcje hash_set::max_load_factor i hash_set::rehash.

Obiekt hash_set obsługuje iteratory dwukierunkowe, co oznacza, że można przejść do sąsiednich elementów, biorąc pod uwagę iterator, który wyznacza element w kontrolowanej sekwencji. Specjalny węzeł główny odpowiada iteratorowi zwróconego przez end()element . Można dekrementować ten iterator, aby uzyskać dostęp do ostatniego elementu w kontrolowanej sekwencji, jeśli istnieje. Można zwiększać iterator, aby uzyskać dostęp do węzła hash_set głównego, a następnie porównać wartość równą end(). Ale nie można wyłusić iteratora zwróconego przez end().

Nie można odwoływać się bezpośrednio do hash_set elementu, biorąc pod uwagę jego położenie liczbowe. Wymaga to iteratora dostępu losowego.

Iterator hash_set przechowuje dojście do skojarzonego hash_set z nim węzła, co z kolei przechowuje dojście do skojarzonego kontenera. Iteratory można używać tylko ze skojarzonymi obiektami kontenera. hash_set Iterator pozostaje prawidłowy tak długo, jak skojarzony hash_set z nim węzeł jest skojarzony z niektórymi hash_set. Co więcej, prawidłowy iterator jest wyłuskiwalny. Można go użyć, aby uzyskać dostęp do lub zmienić wartość elementu, którą wyznaczy, tak długo, jak nie jest równa end().

Wymazywanie lub usuwanie elementu wywołuje destruktor dla jego przechowywanej wartości. Zniszczenie kontenera spowoduje usunięcie wszystkich elementów. W związku z tym kontener, którego typ elementu jest klasą ref, gwarantuje, że żadne elementy nie przeżyją kontenera. Jednak kontener uchwytów nie niszczy swoich elementów.

Elementy członkowskie

hash_set::begin

Określa początek kontrolowanej sekwencji.

Składnia

iterator begin();

Uwagi

Funkcja składowa zwraca iterator dwukierunkowy, który wyznacza pierwszy element kontrolowanej sekwencji lub tuż poza końcem pustej sekwencji. Służy do uzyskania iteratora, który wyznacza current początek kontrolowanej sekwencji, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

// 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

Zlicza liczbę zasobników.

Składnia

int bucket_count();

Uwagi

Funkcja składowa zwraca bieżącą liczbę zasobników. Służy do określania rozmiaru tabeli skrótów.

Przykład

// 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

Usuwa wszystkie elementy.

Składnia

void clear();

Uwagi

Funkcja składowa skutecznie wywołuje funkcję erase(begin(), end()). Służy do zapewnienia, że kontrolowana sekwencja jest pusta.

Przykład

// 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

Typ iteratora stałego dla kontrolowanej sekwencji.

Składnia

typedef T2 const_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T2 , który może służyć jako stały iterator dwukierunkowy dla kontrolowanej sekwencji.

Przykład

// 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

Typ stałego odwołania do elementu.

Składnia

typedef value_type% const_reference;

Uwagi

Typ opisuje stałe odwołanie do elementu.

Przykład

// 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

Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.

Składnia

typedef T4 const_reverse_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T4 , który może służyć jako stały iterator odwrotny dla kontrolowanej sekwencji.

Przykład

// 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

Wyszukuje liczbę elementów pasujących do określonego klucza.

Składnia

size_type count(key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa zwraca liczbę elementów w kontrolowanej sekwencji, które mają równoważną kolejność z key. Służy do określania liczby elementów aktualnie w kontrolowanej sekwencji zgodnej z określonym kluczem.

Przykład

// 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

Typy podpisanej odległości między dwoma elementami.

Składnia

typedef int difference_type;

Uwagi

Typ opisuje prawdopodobnie ujemną liczbę elementów.

Przykład

// 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

Sprawdza, czy nie ma żadnych elementów.

Składnia

bool empty();

Uwagi

Funkcja składowa zwraca wartość true dla pustej kontrolowanej sekwencji. Jest to odpowiednik size() == 0elementu . Służy do testowania, czy element hash_set jest pusty.

Przykład

// 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

Określa koniec kontrolowanej sekwencji.

Składnia

iterator end();

Uwagi

Funkcja składowa zwraca iterator dwukierunkowy, który wskazuje tuż poza koniec kontrolowanej sekwencji. Służy do uzyskania iteratora, który wyznacza koniec kontrolowanej sekwencji; jego stan nie zmienia się, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

// 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

Wyszukuje zakres, który odpowiada określonemu kluczowi.

Składnia

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

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa zwraca parę iteratorów cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Służy do określania zakresu elementów aktualnie w kontrolowanej sekwencji zgodnej z określonym kluczem.

Przykład

// 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

Usuwa elementy z określonych pozycji.

Składnia

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

Parametry

first
Początek zakresu do wymazywania.

key
Wartość klucza do wymazywania.

last
Koniec zakresu do wymazywania.

where
Element do wymazywania.

Uwagi

Pierwsza funkcja składowa usuwa element kontrolowanej sekwencji wskazywanej przez whereelement i zwraca iterator, który wyznacza pierwszy element pozostały poza usuniętym elementem lub end() jeśli taki element nie istnieje. Służy do usuwania pojedynczego elementu.

Druga funkcja składowa usuwa elementy kontrolowanej sekwencji w zakresie [first, last), i zwraca iterator, który wyznacza pierwszy element pozostały poza żadnymi usuniętymi elementami lub end() jeśli taki element nie istnieje. Służy do usuwania zera lub większej liczby ciągłych elementów.

Trzecia funkcja składowa usuwa dowolny element kontrolowanej sekwencji, którego klucz ma równoważne kolejność do key, i zwraca liczbę usuniętych elementów. Służy do usuwania i liczenia wszystkich elementów pasujących do określonego klucza.

Wymazywanie każdego elementu wymaga czasu proporcjonalnego do logarytmu liczby elementów w kontrolowanej sekwencji.

Przykład

// 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

Wyszukuje element, który odpowiada określonemu kluczowi.

Składnia

iterator find(key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Jeśli co najmniej jeden element w kontrolowanej sekwencji ma równoważną kolejność z key, funkcja składowa zwraca iterator wyznaczający jeden z tych elementów; w przeciwnym razie zwraca wartość end(). Służy do lokalizowania elementu aktualnie w kontrolowanej sekwencji zgodnej z określonym kluczem.

Przykład

// 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

Typ interfejsu ogólnego dla kontenera.

Składnia

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

Uwagi

Typ opisuje ogólny interfejs dla tej klasy kontenera szablonu.

Przykład

// 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

Typ iteratora do użycia z interfejsem ogólnym kontenera.

Składnia

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

Uwagi

Typ opisuje iterator ogólny, który może być używany z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

// 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

Typ iteratora odwrotnego do użycia z interfejsem ogólnym kontenera.

Składnia

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

Uwagi

Typ opisuje ogólny iterator odwrotny, który może być używany z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

// 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

Typ elementu do użycia z interfejsem ogólnym kontenera.

Składnia

typedef GValue generic_value;

Uwagi

Typ opisuje obiekt typu GValue , który opisuje przechowywaną wartość elementu do użycia z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

// 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

Wyszukuje element, który odpowiada określonemu kluczowi.

Składnia

hasher^ hash_delegate();

Uwagi

Funkcja składowa zwraca delegata użytego do przekonwertowania wartości klucza na liczbę całkowitą. Służy do tworzenia skrótu klucza.

Przykład

// 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

Konstruuje obiekt kontenera.

Składnia

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);

Parametry

first
Początek zakresu do wstawienia.

hashfn
Funkcja skrótu dla kluczy mapowania na zasobniki.

last
Koniec zakresu do wstawienia.

pred
Kolejność predykatu dla kontrolowanej sekwencji.

right
Obiekt lub zakres do wstawienia.

Uwagi

Konstruktor:

hash_set();

Inicjuje kontrolowaną sekwencję bez elementów z domyślnym predykatem key_compare()porządkowania i domyślną funkcją skrótu. Służy do określania pustej początkowej kontrolowanej sekwencji z domyślną kolejnością predykatu i funkcją skrótu.

Konstruktor:

explicit hash_set(key_compare^ pred);

Inicjuje kontrolowaną sekwencję bez elementów z predykatem predporządkowania i domyślną funkcją skrótu. Służy do określania pustej początkowej kontrolowanej sekwencji z określonym predykatem porządkowania i domyślną funkcją skrótu.

Konstruktor:

hash_set(key_compare^ pred, hasher^ hashfn);

inicjuje kontrolowaną sekwencję bez elementów z predykatem predporządkowania i funkcją hashfnskrótu . Służy do określania pustej początkowej kontrolowanej sekwencji z określonym predykatem porządkowania i funkcją skrótu.

Konstruktor:

hash_set(hash_set<Key>% right);

Inicjuje kontrolowaną sekwencję z sekwencją [right.begin(), right.end()), z domyślnym predykatem porządkowania i domyślną funkcją skrótu. Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez hash_set obiekt right, z domyślną kolejnością predykatu i funkcją skrótu.

Konstruktor:

hash_set(hash_set<Key>^ right);

Inicjuje kontrolowaną sekwencję z sekwencją [right->begin(), right->end()), z domyślnym predykatem porządkowania i domyślną funkcją skrótu. Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez hash_set obiekt right, z domyślną kolejnością predykatu i funkcją skrótu.

Konstruktor:

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

Inicjuje kontrolowaną sekwencję z sekwencją [first, last), z domyślnym predykatem porządkowania i domyślną funkcją skrótu. Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji z domyślną kolejnością predykatu i funkcji skrótu.

Konstruktor:

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

Inicjuje kontrolowaną sekwencję za pomocą sekwencji [first, last), z predykatem predporządkowania i z domyślną funkcją skrótu. Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji z określonym predykatem porządkowania i domyślną funkcją skrótu.

Konstruktor:

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

inicjuje kontrolowaną sekwencję za pomocą sekwencji [first, last), z predykatem predporządkowania i funkcją hashfnskrótu . Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji z określoną kolejnością predykatu i funkcji skrótu.

Konstruktor:

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

inicjuje kontrolowaną sekwencję z sekwencją wyznaczoną przez moduł wyliczający right, z domyślnym predykatem porządkowania i domyślną funkcją skrótu. Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji opisanej przez moduł wyliczający z domyślną funkcją porządkowania i skrótu.

Konstruktor:

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

inicjuje kontrolowaną sekwencję z sekwencją wyznaczoną przez moduł rightwyliczający , z predykatem predporządkowania i domyślną funkcją skrótu. Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji opisanej przez moduł wyliczający z określoną kolejnością predykatu i domyślną funkcją skrótu.

Konstruktor:

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

inicjuje kontrolowaną sekwencję z sekwencją wyznaczoną przez moduł rightwyliczający , z predykatem predporządkowania i funkcją hashfnskrótu . Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji opisanej przez moduł wyliczający z określoną funkcją predykatu porządkowania i skrótu.

Przykład

// 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

Delegat skrótu dla klucza.

Składnia

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

Uwagi

Typ opisuje delegata, który konwertuje wartość klucza na liczbę całkowitą.

Przykład

// 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

Dodaje elementy.

Składnia

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);

Parametry

first
Początek zakresu do wstawienia.

last
Koniec zakresu do wstawienia.

right
Wyliczenie do wstawienia.

val
Wartość klucza do wstawienia.

where
Gdzie w kontenerze do wstawienia (tylko wskazówka).

Uwagi

Każda z funkcji składowych wstawia sekwencję określoną przez pozostałe operandy.

Pierwsza funkcja składowa stara się wstawić element z wartością vali zwraca parę wartości X. Jeśli X.second ma wartość true, X.first wyznacza nowo wstawiony element; w przeciwnym razie X.first wyznacza element z równoważną kolejnością, która już istnieje i nie wstawia nowego elementu. Służy do wstawiania pojedynczego elementu.

Druga funkcja składowa wstawia element z wartością val, używając where jako wskazówki (w celu zwiększenia wydajności) i zwraca iterator, który wyznacza nowo wstawiony element. Służy do wstawiania pojedynczego elementu, który może znajdować się obok elementu, który znasz.

Trzecia funkcja składowa wstawia sekwencję [first, last). Służy do wstawiania zera lub większej liczby elementów skopiowanych z innej sekwencji.

Czwarta funkcja składowa wstawia sekwencję wyznaczoną rightprzez element . Służy do wstawiania sekwencji opisanej przez moduł wyliczający.

Każde wstawienie elementu wymaga czasu proporcjonalnego do logarytmu liczby elementów w kontrolowanej sekwencji. Wstawianie może wystąpić w zamortyzowanym stałym czasie, jednak biorąc pod uwagę wskazówkę, która wyznacza element obok punktu wstawiania.

Przykład

// 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

Typ iteratora dla kontrolowanej sekwencji.

Składnia

typedef T1 iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T1 , który może służyć jako iterator dwukierunkowy dla kontrolowanej sekwencji.

Przykład

// 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

Kopiuje delegata porządkowania dla dwóch kluczy.

Składnia

key_compare^key_comp();

Uwagi

Funkcja składowa zwraca delegata porządkowania używanego do porządkowania kontrolowanej sekwencji. Służy do porównywania dwóch kluczy.

Przykład

// 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

Delegat porządkowania dla dwóch kluczy.

Składnia

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

Uwagi

Typ jest synonimem delegata, który określa kolejność jego kluczowych argumentów.

Przykład

// 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

Typ klucza sortowania.

Składnia

typedef Key key_type;

Uwagi

Typ jest synonimem parametru Keyszablonu .

Przykład

// 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

Oblicza średnią liczbę elementów na przedział.

Składnia

float load_factor();

Uwagi

Funkcja składowa zwraca wartość (float)size() / bucket_count(). Służy do określania średniego rozmiaru zasobnika.

Przykład

// 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

Znajduje początek zakresu, który pasuje do określonego klucza.

Składnia

iterator lower_bound(key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa określa pierwszy element X w kontrolowanej sekwencji, który skróty do tego samego zasobnika co key i ma równoważne kolejność do key. Jeśli taki element nie istnieje, zwraca end()wartość ; w przeciwnym razie zwraca iterator, który wyznacza Xwartość . Służy do lokalizowania początku sekwencji elementów aktualnie w kontrolowanej sekwencji, która jest zgodna z określonym kluczem.

Przykład

// 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

Tworzy obiekt wartości.

Składnia

static value_type make_value(key_type key);

Parametry

key
Wartość klucza do użycia.

Uwagi

Funkcja składowa zwraca value_type obiekt, którego kluczem jest key. Służy do tworzenia obiektu odpowiedniego do użycia z kilkoma innymi funkcjami składowymi.

Przykład

// 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

Pobiera lub ustawia maksymalną liczbę elementów na przedział.

Składnia

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

Parametry

new_factor
Nowy maksymalny współczynnik obciążenia do przechowywania.

Uwagi

Pierwsza funkcja składowa zwraca bieżący przechowywany maksymalny współczynnik obciążenia. Służy do określania maksymalnego średniego rozmiaru zasobnika.

Druga funkcja składowa zastępuje maksymalny współczynnik obciążenia magazynu parametrem new_factor. Nie ma automatycznego ponownego mieszania do momentu późniejszego wstawienia.

Przykład

// 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=

Zastępuje kontrolowaną sekwencję.

Składnia

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

Parametry

right
Kontener do skopiowania.

Uwagi

Operator elementu członkowskiego kopiuje right do obiektu, a następnie zwraca wartość *this. Służy do zastępowania kontrolowanej sekwencji kopią kontrolowanej sekwencji w pliku right.

Przykład

// 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

Wyznacza początek odwróconej kontrolowanej sekwencji.

Składnia

reverse_iterator rbegin();

Uwagi

Funkcja składowa zwraca iterator odwrotny, który wyznacza ostatni element kontrolowanej sekwencji lub tuż poza początkiem pustej sekwencji. W związku z tym wyznacza beginning sekwencję odwrotną. Służy do uzyskania iteratora, który wyznacza current początek kontrolowanej sekwencji widocznej w odwrotnej kolejności, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

// 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

Typ odwołania do elementu.

Składnia

typedef value_type% reference;

Uwagi

Typ opisuje odwołanie do elementu.

Przykład

// 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

Przebudowuje tabelę mieszania.

Składnia

void rehash();

Uwagi

Funkcja składowa ponownie kompiluje tabelę skrótów, zapewniając, że load_factor() <= max_load_factor(). W przeciwnym razie tabela skrótów zwiększa rozmiar tylko zgodnie z potrzebami po wstawieniu. (Nigdy nie zmniejsza rozmiaru). Służy do dostosowywania rozmiaru tabeli skrótów.

Przykład

// 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

Wyznacza koniec odwróconej kontrolowanej sekwencji.

Składnia

reverse_iterator rend();

Uwagi

Funkcja składowa zwraca iterator odwrotny, który wskazuje tuż poza początkiem kontrolowanej sekwencji. W związku z tym wyznacza end sekwencję odwrotną. Służy do uzyskania iteratora, który wyznacza current koniec kontrolowanej sekwencji widocznej w odwrotnej kolejności, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

// 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

Typ iteratora odwrotnego dla kontrolowanej sekwencji.

Składnia

typedef T3 reverse_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T3 , który może służyć jako iterator odwrotny dla kontrolowanej sekwencji.

Przykład

// 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

Liczy liczbę elementów.

Składnia

size_type size();

Uwagi

Funkcja składowa zwraca długość kontrolowanej sekwencji. Służy do określania liczby elementów aktualnie w kontrolowanej sekwencji. Jeśli chodzi o to, czy sekwencja ma rozmiar niezerowy, zobacz empty().

Przykład

// 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

Typ odległości ze znakiem między dwoma elementami.

Składnia

typedef int size_type;

Uwagi

Typ opisuje nieujemną liczbę elementów.

Przykład

// 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

Zamienia zawartości dwóch kontenerów.

Składnia

void swap(hash_set<Key>% right);

Parametry

right
Kontener do zamiany zawartości na.

Uwagi

Funkcja składowa zamienia kontrolowane sekwencje między this i right. Robi to w stałym czasie i nie zgłasza żadnych wyjątków. Służy ona jako szybki sposób wymiany zawartości dwóch kontenerów.

Przykład

// 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

Kopiuje kontrolowaną sekwencję do nowej tablicy.

Składnia

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

Uwagi

Funkcja składowa zwraca tablicę zawierającą kontrolowaną sekwencję. Służy do uzyskiwania kopii kontrolowanej sekwencji w postaci tablicy.

Przykład

// 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

Znajduje koniec zakresu, który pasuje do określonego klucza.

Składnia

iterator upper_bound(key_type key);

Parametry

key
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa określa ostatni element X w kontrolowanej sekwencji, który skróty do tego samego zasobnika co key i ma równoważne kolejność .key Jeśli taki element nie istnieje lub jeśli X jest ostatnim elementem w kontrolowanej sekwencji, zwraca wartość ; w przeciwnym razie zwraca end()iterator, który wyznacza pierwszy element poza X. Służy do lokalizowania końca sekwencji elementów aktualnie w kontrolowanej sekwencji, która jest zgodna z określonym kluczem.

Przykład

// 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

Kopiuje delegata porządkowania dla dwóch wartości elementów.

Składnia

value_compare^ value_comp();

Uwagi

Funkcja składowa zwraca delegata porządkowania używanego do porządkowania kontrolowanej sekwencji. Służy do porównywania dwóch wartości elementów.

Przykład

// 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

Delegat porządkowania dla dwóch wartości elementów.

Składnia

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

Uwagi

Typ jest synonimem delegata, który określa kolejność argumentów jego wartości.

Przykład

// 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

Typ elementu.

Składnia

typedef generic_value value_type;

Uwagi

Typ jest synonimem .generic_value

Przykład

// 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