hash_set — Klasa

Artykuł
10/12/2023

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Klasa kontenera hash_set jest rozszerzeniem standardowej biblioteki C++ i służy do przechowywania i szybkiego pobierania danych z kolekcji, w której zawarte wartości są unikatowe i służą jako wartości klucza.

Składnia

template <class Key,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<Key>>
class hash_set

Parametry

Klawisz
Typ danych elementu, który ma być przechowywany w hash_set.

Cechy
Typ, który zawiera dwa obiekty funkcji, jeden z porównań klas, który jest predykatem binarnym w stanie porównać dwie wartości elementu jako klucze sortowania w celu określenia ich względnej kolejności i funkcji skrótu, która jest jednoargumentowym mapowaniem kluczowych wartości kluczy elementów na niepodpisane liczby całkowite typu size_t. Ten argument jest opcjonalny i hash_compare<Key, less<Key> > jest wartością domyślną.

Programu przydzielania
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące alokacji hash_set i cofnięcia alokacji pamięci. Ten argument jest opcjonalny, a wartość domyślna to allocator<Key>.

Uwagi

Hash_set to:

Kontenerem asocjacyjnym, który jest kontenerem o zmiennym rozmiarze, obsługującym efektywne pobieranie wartości elementu w oparciu o wartość skojarzonego klucza. Ponadto, jest prostym kontenerem asocjacyjnym, ponieważ jego wartości elementu są jego wartościami klucza.
Odwracalny, ponieważ zapewnia dwukierunkowy iterator do dostępu do jego elementów.
Skrót, ponieważ jego elementy są pogrupowane w zasobniki na podstawie wartości funkcji skrótu zastosowanej do kluczowych wartości elementów.
Unikatowy w tym sensie, że każdy z jego elementów musi mieć unikatowy klucz. Ponieważ hash_set jest również prostym kontenerem asocjacyjnym, jego elementy są również unikatowe.
Szablon klasy, ponieważ funkcje, które udostępnia, są ogólne i tak niezależne od określonego typu danych zawartych jako elementy lub klucze. Typy danych, których można użyć dla elementów i kluczy, są zamiast tego określane jako parametry w szablonie klasy, wraz z funkcją porównania oraz alokatorem.

Główną zaletą tworzenia skrótów w sortowaniu jest większa wydajność; Pomyślne utworzenie skrótu wykonuje operacje wstawiania, usuwania i znajduje się w stałym średnim czasie w porównaniu z czasem proporcjonalnym do logarytmu liczby elementów w kontenerze na potrzeby technik sortowania. Nie można bezpośrednio zmienić wartości elementu w zestawie. Zamiast tego musisz usunąć stare wartości i wstawić elementy z nowymi wartościami.

Wybór typu kontenera powinien ogólnie być oparty o typ wyszukiwania i wstawiania wymagany przez aplikację. Skróty kontenerów asocjacyjnych są zoptymalizowane pod kątem operacji wyszukiwania, wstawiania i usuwania. Funkcje składowe, które jawnie obsługują te operacje, są wydajne w przypadku użycia z dobrze zaprojektowaną funkcją skrótu, wykonując je w czasie, który jest średnio stały i nie zależy od liczby elementów w kontenerze. Dobrze zaprojektowana funkcja skrótu tworzy jednolity rozkład wartości skrótów i minimalizuje liczbę kolizji, gdzie mówi się, że kolizja występuje, gdy różne wartości klucza są mapowane na tę samą wartość skrótu. W najgorszym przypadku z najgorszą możliwą funkcją skrótu liczba operacji jest proporcjonalna do liczby elementów w sekwencji (czas liniowy).

Hash_set powinien być wybranym kontenerem asocjacyjnym, gdy warunki kojarzące wartości z kluczami są spełnione przez aplikację. Elementy hash_set są unikatowe i służą jako własne klucze sortowania. Model dla tego typu konstrukcji jest uporządkowaną listą, np. wyrazów, w których wyrazy mogą występować tylko raz. Jeśli dozwolone było wiele wystąpień wyrazów, hash_multiset byłaby odpowiednią strukturą kontenera. Jeśli wartości muszą być dołączone do listy unikatowych słów kluczowych, hash_map byłaby odpowiednią strukturą zawierającą te dane. Jeśli zamiast tego klucze nie są unikatowe, hash_multimap będzie kontenerem do wyboru.

Hash_set porządkuje sekwencję, którą kontroluje, wywołując przechowywany obiekt skrótu Traits typu value_compare. Dostęp do tego przechowywanego obiektu można uzyskać, wywołując funkcję składową key_comp. Taki obiekt funkcji musi zachowywać się tak samo jak obiekt klasy hash_compare<Klucz, mniej<Klucz>>. W szczególności dla wszystkich wartości key typu Klucz wywołanie Cecha(key) zwraca rozkład wartości typu size_t.

Ogólnie rzecz biorąc, elementy muszą być nieco mniej porównywalne, aby ustalić kolejność: tak aby, mając dowolne dwa elementy, można było określić, czy są one równoważne (w sensie, żaden nie jest mniejszy niż ten drugi) lub, że jeden jest mniejszy niż ten drugi. Powoduje to kolejność między elementami, które nie są równoważne. Ze strony bardziej technicznej, funkcja porównywania jest predykatem binarnym, który wymusza ścisłe słabe porządkowanie w standardowym sensie matematycznym. Predykat binarny f( x, y) jest obiektem funkcji, który ma dwa obiekty argumentów x i y oraz zwracaną wartość true lub false. Kolejność nałożona na hash_set to ścisłe słabe porządkowanie, jeśli predykat binarny jest nieelastycznym, antysymetrycznym i przechodnim, a jeśli równoważność jest przechodnia, gdzie dwa obiekty x i y są definiowane jako równoważne, gdy oba obiekty f( x, y) i f( y, x) są fałszywe. Jeśli silniejszy warunek równości pomiędzy kluczami zastąpi ten równoważności, to porządkowanie będzie całkowite (w sensie, że wszystkie elementy są uporządkowane względem siebie), a dopasowane klucze będą od siebie nieodróżnialne.

Rzeczywista kolejność elementów w kontrolowanej sekwencji zależy od funkcji skrótu, funkcji porządkowania i bieżącego rozmiaru tabeli skrótów przechowywanej w obiekcie kontenera. Nie można określić bieżącego rozmiaru tabeli skrótów, więc nie można ogólnie przewidzieć kolejności elementów w kontrolowanej sekwencji. Wstawianie elementów nie unieważnia iteratorów, a usuwanie elementów unieważnia tylko te iteratory, które w szczególności wskazywały na usunięte elementy.

Iterator dostarczany przez klasę hash_set jest iteratorem dwukierunkowym, ale funkcje składowe klasy wstawiają i hash_set mają wersje, które przyjmują jako parametry szablonu słabszy iterator wejściowy, którego wymagania dotyczące funkcjonalności są bardziej minimalne niż te gwarantowane przez klasę iteratorów dwukierunkowych. Pojęcia innych iteratorów formują rodzinę powiązaną przez udoskonalenia w ich funkcjonalnościach. Każde pojęcie iteratora ma swój własny zestaw wymagań, a algorytmy z nimi pracujące muszą ograniczać swoje założenia co do wymagań dostarczonych przez tego typu iterator. Można założyć, że z iteratora danych wejściowych można usunąć odwołanie, aby odwołać się do obiektu, a także, że może on być zwiększony do następnego iteratora w sekwencji. Jest to minimalny zestaw funkcji, ale wystarczy, aby móc mówić znacząco o zakresie iteratorów [ first, last) w kontekście funkcji składowych klasy.

Konstruktory

Konstruktor	opis
hash_set	Tworzy element, który `hash_set` jest pusty lub jest kopią wszystkich lub części innych `hash_set`elementów .

Typedefs

Nazwa typu	opis
allocator_type	Typ reprezentujący klasę `allocator` `hash_set` dla obiektu.
const_iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytać `const` element w obiekcie `hash_set`.
const_pointer	Typ, który dostarcza wskaźnik do `const` elementu w obiekcie `hash_set`.
const_reference	Typ, który zawiera odwołanie do elementu przechowywanego `const` w `hash_set` obiekcie do odczytu i wykonywania `const` operacji.
const_reverse_iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny `const` element w obiekcie `hash_set`.
difference_type	Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów `hash_set` w zakresie między elementami wskazywanym przez iteratory.
Sterująca	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować dowolny element w obiekcie `hash_set`.
key_compare	Typ, który udostępnia obiekt funkcji, który może porównać dwa klucze sortowania, aby określić względną kolejność dwóch elementów w obiekcie `hash_set`.
key_type	Typ, który opisuje obiekt przechowywany jako element `hash_set` w jego pojemności jako klucz sortowania.
wskaźnik	Typ, który dostarcza wskaźnik do elementu w elemecie `hash_set`.
odniesienie	Typ, który zawiera odwołanie do elementu przechowywanego w obiekcie `hash_set`.
reverse_iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować element w odwróconym `hash_set`obiekcie .
size_type	Niepodpisany typ liczb całkowitych, który może reprezentować liczbę elementów w obiekcie `hash_set`.
value_compare	Typ, który udostępnia dwa obiekty funkcji, binarny predykat klasy porównywania, który może porównać dwie wartości elementów elementu w `hash_set` celu określenia ich względnej kolejności i jednoargumentowego predykatu, który skróty elementów.
value_type	Typ, który opisuje obiekt przechowywany jako element `hash_set` w jego pojemności jako wartość.

Funkcje składowe

Funkcja składowa	opis
zaczynać	Zwraca iterator, który adresuje pierwszy element w obiekcie `hash_set`.
cbegin	Zwraca iterator const odnoszący się do pierwszego elementu w obiekcie `hash_set`.
cend	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie `hash_set`.
jasny	Usuwa wszystkie elementy elementu `hash_set`.
count	Zwraca liczbę elementów w kluczu `hash_set` , których klucz pasuje do klucza określonego parametrem.
crbegin	Zwraca iterator const odnoszący się do pierwszego elementu w odwróconym `hash_set`obiekcie .
crend	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie `hash_set`.
miejsce	Wstawia element skonstruowany w miejscu do elementu `hash_set`.
emplace_hint	Wstawia element skonstruowany w miejscu do `hash_set`elementu z wskazówką umieszczania.
empty	Sprawdza, czy element `hash_set` jest pusty.
koniec	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie `hash_set`.
equal_range	Zwraca parę iteratorów odpowiednio do pierwszego elementu w `hash_set` obiekcie z kluczem większym niż określony klucz i do pierwszego elementu w `hash_set` obiekcie z kluczem równym lub większym niż klucz.
wymazać	Usuwa element lub zakres elementów z `hash_set` określonych pozycji lub usuwa elementy zgodne z określonym kluczem.
find	Zwraca iterator odnoszący się do lokalizacji elementu w obiekcie `hash_set` , który ma klucz odpowiadający określonemu kluczowi.
get_allocator	Zwraca kopię obiektu używanego `allocator` do konstruowania obiektu `hash_set`.
wstawiać	Wstawia element lub zakres elementów do elementu `hash_set`.
key_comp	Pobiera kopię obiektu porównania używanego do zamawiania kluczy w obiekcie `hash_set`.
lower_bound	Zwraca iterator do pierwszego elementu w obiekcie `hash_set` z kluczem równym lub większym niż określony klucz.
max_size	Zwraca maksymalną długość obiektu `hash_set`.
rbegin	Zwraca iterator odnoszący się do pierwszego elementu w odwróconym `hash_set`obiekcie .
drzeć	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie `hash_set`.
rozmiar	Zwraca liczbę elementów w elem.`hash_set`
zamiana	Wymienia elementy dwóch `hash_set`s.
upper_bound	Zwraca iterator do pierwszego elementu w obiekcie `hash_set` z kluczem równym lub większym niż określony klucz.
value_comp	Pobiera kopię obiektu cech skrótu używanego do określania wartości klucza elementu skrótu i porządkowanie ich w obiekcie `hash_set`.

Operatory

Operator	opis
hash_set::operator=	Zastępuje elementy elementu `hash_set` kopią innego `hash_set`elementu .

Wymagania

Nagłówek:<hash_set>

Przestrzeń nazw: stdext

hash_set::allocator_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ reprezentujący klasę alokatora dla obiektu hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

Uwagi

allocator_typejest synonimem allocator parametru szablonu.

Aby uzyskać więcej informacji na temat alokatora, zobacz sekcję Uwagi w temacie hash_set Class (Klasa hash_set).

Przykład

Zobacz przykład get_allocator, aby zapoznać się z przykładem, który używa elementu allocator_type.

hash_set::begin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator, który adresuje pierwszy element w hash_set.

const_iterator begin() const;

iterator begin();

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu w hash_set lub lokalizacji, która zakończyła się powodzeniem pustej hash_set.

Uwagi

Jeśli wartość zwracana begin elementu jest przypisana do const_iteratorobiektu , nie można modyfikować elementów w obiekcie hash_set. Jeśli wartość zwracana begin elementu jest przypisana do iteratorobiektu , elementy w obiekcie hash_set można modyfikować.

Przykład

// hash_set_begin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_Iter = hs1.begin( );
   cout << "The first element of hs1 is " << *hs1_Iter << endl;

   hs1_Iter = hs1.begin( );
   hs1.erase( hs1_Iter );

   // The following 2 lines would err because the iterator is const
   // hs1_cIter = hs1.begin( );
   // hs1.erase( hs1_cIter );

   hs1_cIter = hs1.begin( );
   cout << "The first element of hs1 is now " << *hs1_cIter << endl;
}

The first element of hs1 is 1
The first element of hs1 is now 2

hash_set::cbegin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator const, który adresuje pierwszy element w hash_set.

const_iterator cbegin() const;

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu w hash_set lub lokalizacji, która zakończyła się powodzeniem pustego hash_setelementu .

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w hash_set obiekcie.

Przykład

// hash_set_cbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cbegin( );
   cout << "The first element of hs1 is " << *hs1_cIter << endl;
}

The first element of hs1 is 1

hash_set::cend

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_set.

const_iterator cend() const;

Wartość zwracana

Iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_set. Jeśli wartość jest pusta hash_set , to hash_set::cend == hash_set::begin.

Uwagi

cend służy do testowania, czy iterator osiągnął koniec jego hash_set. Wartość zwracana przez cend nie powinna być wyłuszczone.

Przykład

// hash_set_cend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cend( );
   hs1_cIter--;
   cout << "The last element of hs1 is " << *hs1_cIter << endl;
}

The last element of hs1 is 3

hash_set::clear

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Usuwa wszystkie elementy hash_set.

void clear();

Uwagi

Przykład

// hash_set_clear.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 1 );
   hs1.insert( 2 );

   cout << "The size of the hash_set is initially " << hs1.size( )
        << "." << endl;

   hs1.clear( );
   cout << "The size of the hash_set after clearing is "
        << hs1.size( ) << "." << endl;
}

The size of the hash_set is initially 2.
The size of the hash_set after clearing is 0.

hash_set::const_iterator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który udostępnia iterator dwukierunkowy, który może odczytać const element w hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

Uwagi

Nie można użyć typu const_iterator do modyfikowania wartości elementu.

Przykład

Zobacz przykład, aby zapoznać się z przykładem, który używa elementu const_iterator.

hash_set::const_pointer

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który dostarcza wskaźnik do const elementu w hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_pointer const_pointer;

Uwagi

Nie można użyć typu const_pointer do modyfikowania wartości elementu.

W większości przypadków const_iterator należy użyć do uzyskiwania dostępu do elementów w const obiekcie hash_set.

hash_set::const_reference

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który zawiera odwołanie do elementu przechowywanego const w hash_set do odczytywania i wykonywania const operacji.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reference const_reference;

Uwagi

Przykład

// hash_set_const_ref.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 10 );
   hs1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *hs1.begin( );

   cout << "The first element in the hash_set is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference cannot be used to modify the hash_set
   // Ref1 = Ref1 + 5;
}

The first element in the hash_set is 10.

hash_set::const_reverse_iterator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny const element w hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse_iterator const_reverse_iterator;

Uwagi

Typ const_reverse_iterator nie może zmodyfikować wartości elementu i jest używany do iterowania przez hash_set odwrotnie.

Przykład

Zobacz przykład dla nazwy rend, aby zapoznać się z przykładem sposobu deklarowania i używaniaconst_reverse_iterator

hash_set::count

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca liczbę elementów w hash_set, których klucz pasuje do klucza określonego parametrem.

size_type count(const Key& key) const;

Parametry

key
Klucz elementów do dopasowania z hash_set.

Wartość zwracana

1 jeśli hash_set zawiera element, którego klucz sortowania pasuje do klucza parametru.

0, jeśli hash_set nie zawiera elementu z pasującym kluczem.

Uwagi

Funkcja składowa zwraca liczbę elementów w następującym zakresie:

[ lower_bound(klucz), upper_bound(klucz) ).

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej hash_set::count.

// hash_set_count.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1;
    hash_set<int>::size_type i;

    hs1.insert(1);
    hs1.insert(1);

    // Keys must be unique in hash_set, so duplicates are ignored.
    i = hs1.count(1);
    cout << "The number of elements in hs1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hs1.count(2);
    cout << "The number of elements in hs1 with a sort key of 2 is: "
         << i << "." << endl;
}

The number of elements in hs1 with a sort key of 1 is: 1.
The number of elements in hs1 with a sort key of 2 is: 0.

hash_set::crbegin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator const odnoszący się do pierwszego elementu w odwróconej hash_set.

const_reverse_iterator crbegin() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu w odwróconej hash_set lub zwracając się do tego, co było ostatnim elementem w niewróceniu hash_set.

Uwagi

crbegin jest używany z odwróconym hash_set tak samo jak hash_set::begin jest używany z hash_set.

Przy użyciu wartości zwracanej crbeginhash_set obiektu nie można modyfikować.

crbegin może służyć do iterowania przez hash_set tyły.

Przykład

// hash_set_crbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_crIter << "." << endl;
}

The first element in the reversed hash_set is 30.

hash_set::crend

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconej hash_set.

const_reverse_iterator crend() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconej hash_set (lokalizacja, która poprzedzała pierwszy element w niewróconym hash_setelemecie ).

Uwagi

crend jest używany z odwróconym elementem hash_set tak samo jak hash_set::end jest używany z elementem hash_set.

Przy użyciu wartości zwracanej crendhash_set obiektu nie można modyfikować.

crend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego hash_set.

Przykład

// hash_set_crend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crend( );
   hs1_crIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_crIter << "." << endl;
}

The last element in the reversed hash_set is 10.

hash_set::d ifference_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów hash_set w zakresie między elementami wskazywanym przez iteratory.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::difference_type difference_type;

Uwagi

Jest difference_type to typ zwracany podczas odejmowania lub przyrostowania przez iteratory kontenera. Element difference_type jest zwykle używany do reprezentowania liczby elementów w zakresie [ first, last) między iteratorami first i last, zawiera element wskazywany przez first i zakres elementów do, ale nie uwzględnia, element wskazywany przez last.

Należy pamiętać, że chociaż difference_type jest dostępny dla wszystkich iteratorów spełniających wymagania iteratora wejściowego, który obejmuje klasę iteratorów dwukierunkowych obsługiwanych przez kontenery odwracalne, takie jak zestaw, odejmowanie między iteratorami jest obsługiwane tylko przez iteratory dostępu losowego udostępniane przez kontener dostępu losowego, takie jak wektor lub deque.

Przykład

// hash_set_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_set>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter, hs1_bIter, hs1_eIter;

   hs1.insert( 20 );
   hs1.insert( 10 );
   hs1.insert( 20 );   // Won't insert as hash_set elements are unique

   hs1_bIter = hs1.begin( );
   hs1_eIter = hs1.end( );

   hash_set <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( hs1_bIter, hs1_eIter, 5 );
   df_typ10 = count( hs1_bIter, hs1_eIter, 10 );
   df_typ20 = count( hs1_bIter, hs1_eIter, 20 );

   // The keys, and hence the elements, of a hash_set are unique,
   // so there is at most one of a given value
   cout << "The number '5' occurs " << df_typ5
        << " times in hash_set hs1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in hash_set hs1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in hash_set hs1.\n";

   // Count the number of elements in a hash_set
   hash_set <int>::difference_type  df_count = 0;
   hs1_Iter = hs1.begin( );
   while ( hs1_Iter != hs1_eIter)
   {
      df_count++;
      hs1_Iter++;
   }

   cout << "The number of elements in the hash_set hs1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in hash_set hs1.
The number '10' occurs 1 times in hash_set hs1.
The number '20' occurs 1 times in hash_set hs1.
The number of elements in the hash_set hs1 is: 2.

hash_set::emplace

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Wstawia element skonstruowany na miejscu do hash_set.

template <class ValTy>
pair <iterator, bool>
emplace(
    ValTy&& val);

Parametry

Val
Wartość elementu, który ma zostać wstawiony do hash_set , chyba że hash_set element zawiera już ten element lub, ogólniej, element, którego klucz jest równoważnie uporządkowany.

Wartość zwracana

emplace Funkcja składowa zwraca parę, której bool składnik zwracatrue, jeśli wstawienie zostało wprowadzone, a false jeśli hash_set już zawierał element, którego klucz miał równoważną wartość w kolejności, i którego składnik iteratora zwraca adres, w którym wstawiono nowy element lub gdzie element został już zlokalizowany.

Uwagi

Przykład

// hash_set_emplace.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<string> hs3;
   string str1("a");

   hs3.emplace(move(str1));
   cout << "After the emplace insertion, hs3 contains "
      << *hs3.begin() << "." << endl;
}

After the emplace insertion, hs3 contains a.

hash_set::emplace_hint

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Wstawia element skonstruowany na miejscu do hash_set.

template <class ValTy>
iterator emplace(
    const_iterator _Where,
    ValTy&& val);

Parametry

Val
Wartość elementu, który ma zostać wstawiony do hash_set , chyba że hash_set element zawiera już ten element lub, ogólniej, element, którego klucz jest równoważnie uporządkowany.

_Gdzie
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania. (Wstawienie może wystąpić w amortyzowanym stałym czasie, zamiast czasu logarytmicznych, jeśli punkt wstawiania natychmiast następuje _Where).

Wartość zwracana

Funkcja składowa hash_set::emplace zwraca iterator wskazujący położenie, w którym nowy element został wstawiony do hash_setelementu , lub gdzie znajduje się istniejący element z równoważną kolejnością.

Uwagi

Wstawienie może wystąpić w amortyzowanym czasie stałym, a nie w czasie logarytmicznych, jeśli punkt wstawiania natychmiast następuje _Where.

Przykład

// hash_set_emplace_hint.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<string> hs3;
   string str1("a");

   hs3.insert(hs3.begin(), move(str1));
   cout << "After the emplace insertion, hs3 contains "
      << *hs3.begin() << "." << endl;
}

After the emplace insertion, hs3 contains a.

hash_set::empty

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Sprawdza, czy hash_set jest pusta.

bool empty() const;

Wartość zwracana

true jeśli hash_set jest pusta; false jeśli hash_set jest brak.

Uwagi

Przykład

// hash_set_empty.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2;
   hs1.insert ( 1 );

   if ( hs1.empty( ) )
      cout << "The hash_set hs1 is empty." << endl;
   else
      cout << "The hash_set hs1 is not empty." << endl;

   if ( hs2.empty( ) )
      cout << "The hash_set hs2 is empty." << endl;
   else
      cout << "The hash_set hs2 is not empty." << endl;
}

The hash_set hs1 is not empty.
The hash_set hs2 is empty.

hash_set::end

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_set.

const_iterator end() const;

iterator end();

Wartość zwracana

Iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_set. Jeśli hash_set jest pusta, hash_set::end == hash_set::begin.

Uwagi

end służy do testowania, czy iterator osiągnął koniec hash_set. Wartość zwracana przez end nie powinna być wyłuszczone.

Przykład

// hash_set_end.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: iterator hs1_Iter;
   hash_set <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_Iter = hs1.end( );
   hs1_Iter--;
   cout << "The last element of hs1 is " << *hs1_Iter << endl;

   hs1.erase( hs1_Iter );

   // The following 3 lines would err because the iterator is const:
   // hs1_cIter = hs1.end( );
   // hs1_cIter--;
   // hs1.erase( hs1_cIter );

   hs1_cIter = hs1.end( );
   hs1_cIter--;
   cout << "The last element of hs1 is now " << *hs1_cIter << endl;
}

The last element of hs1 is 3
The last element of hs1 is now 2

hash_set::equal_range

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca parę iteratorów odpowiednio do pierwszego elementu w zestawie skrótów z kluczem, który jest równy określonemu kluczowi i pierwszemu elementowi w ustawieniu skrótu z kluczem większym niż klucz.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parametry

key
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego hash_set.

Wartość zwracana

Para iteratorów, gdzie pierwszy to lower_bound klucza, a drugi to upper_bound klucza.

Aby uzyskać dostęp do pierwszego iteratora pary pr zwróconej przez funkcję składową, użyj polecenia pr. najpierw i aby wyłusić iterator dolnej granicy, użyj *( pr. pierwszy). Aby uzyskać dostęp do drugiego iteratora pary pr zwróconej przez funkcję składową, użyj polecenia pr. drugi i aby wyłuskać iterator górnej granicy, użyj *( pr. sekunda).

Uwagi

Przykład

// hash_set_equal_range.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_set<int> IntHSet;
   IntHSet hs1;
   hash_set <int> :: const_iterator hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   pair <IntHSet::const_iterator, IntHSet::const_iterator> p1, p2;
   p1 = hs1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.first) << "." << endl;

   // Compare the upper_bound called directly
   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *hs1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = hs1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hs1.end( ) ) && ( p2.second == hs1.end( ) ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key greater than or equal to 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key >= 40 is: "
           << *(p1.first) << "." << endl;
}

The upper bound of the element with a key of 20 in the hash_set hs1 is: 30.
The lower bound of the element with a key of 20 in the hash_set hs1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The hash_set hs1 doesn't have an element with a key greater than or equal to 40.

hash_set::erase

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Usuwa element lub zakres elementów w hash_set z określonych pozycji lub usuwa elementy zgodne z określonym kluczem.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parametry

_Gdzie
Położenie elementu do usunięcia z hash_set.

pierwszy
Pozycja pierwszego elementu usunięta z hash_set.

ostatni
Pozycja tuż poza ostatnim elementem usuniętym z hash_set.

key
Klucz elementów do usunięcia z hash_set.

Wartość zwracana

W przypadku pierwszych dwóch funkcji składowych iterator dwukierunkowy, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub wskaźnik na końcu hash_set, jeśli taki element nie istnieje. W przypadku trzeciej funkcji składowej liczba elementów, które zostały usunięte z hash_set.

Uwagi

Funkcje składowe nigdy nie zgłaszają wyjątku.

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej hash_set::erase.

// hash_set_erase.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1, hs2, hs3;
    hash_set<int>::iterator pIter, Iter1, Iter2;
    int i;
    hash_set<int>::size_type n;

    for (i = 1; i < 5; i++)
    {
        hs1.insert (i);
        hs2.insert (i * i);
        hs3.insert (i - 1);
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hs1.begin();
    hs1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_set hs1 is:";
    for (pIter = hs1.begin(); pIter != hs1.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hs2.begin();
    Iter2 = --hs2.end();
    hs2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_set hs2 is:";
    for (pIter = hs2.begin(); pIter != hs2.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hs3.erase(2);

    cout << "After the element with a key of 2 is deleted, "
         << "the hash_set hs3 is:";
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hs3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hs3.begin();
    hs3.erase(Iter1);

    cout << "After another element (unique for hash_set) with a key "
         << endl;
    cout  << "equal to that of the 2nd element is deleted, "
          << "the hash_set hs3 is:";
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_set hs1 is: 1 3 4.
After the middle two elements are deleted, the hash_set hs2 is: 16 4.
After the element with a key of 2 is deleted, the hash_set hs3 is: 0 1 3.
The number of elements removed from hs3 is: 1.
After another element (unique for hash_set) with a key
equal to that of the 2nd element is deleted, the hash_set hs3 is: 0 3.

hash_set::find

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator adresujący lokalizację elementu w hash_set, który ma klucz odpowiadający określonemu kluczowi.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Klucz argumentu, który ma być dopasowany przez klucz sortowania elementu z przeszukiwanego hash_set.

Wartość zwracana

Element iterator lub const_iterator adresujący lokalizację elementu równoważnego określonemu kluczowi lub adresujący lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_set, jeśli nie znaleziono dopasowania dla klucza.

Uwagi

Funkcja składowa zwraca iterator, który adresuje element w hash_set, którego kluczem sortowania jest equivalent klucz argumentu w predykacie binarnym, który wywołuje kolejność na podstawie relacji mniejszej niż porównywalność.

Jeśli zwracana wartość find elementu jest przypisana do const_iteratorobiektu , nie można zmodyfikować obiektu hash_set. Jeśli wartość zwracana find elementu jest przypisana do iteratorobiektu , można zmodyfikować obiekt hash_set.

Przykład

// hash_set_find.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.find( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.find( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key of 40 is: "
           << *hs1_RcIter << "." << endl;

   // The element at a specific location in the hash_set can be found
   // by using a dereferenced iterator addressing the location
   hs1_AcIter = hs1.end( );
   hs1_AcIter--;
   hs1_RcIter = hs1.find( *hs1_AcIter );
   cout << "The element of hs1 with a key matching "
        << "that of the last element is: "
        << *hs1_RcIter << "." << endl;
}

The element of hash_set hs1 with a key of 20 is: 20.
The hash_set hs1 doesn't have an element with a key of 40.
The element of hs1 with a key matching that of the last element is: 30.

hash_set::get_allocator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca kopię obiektu alokatora używanego do konstruowania hash_set.

Allocator get_allocator() const;

Wartość zwracana

Alokator używany przez hash_set do zarządzania pamięcią, czyli alokator parametru szablonu.

Aby uzyskać więcej informacji na temat alokatora, zobacz sekcję Uwagi w temacie hash_set Class (Klasa hash_set).

Uwagi

Alokatory dla klasy hash_set określają sposób zarządzania magazynem przez klasę. Domyślne alokatory dostarczane z klasami kontenerów biblioteki standardowej języka C++ są wystarczające dla większości potrzeb programistycznych. Pisanie i używanie własnej klasy alokatora jest zaawansowanym tematem języka C++.

Przykład

// hash_set_get_allocator.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   // The following lines declare objects
   // that use the default allocator.
   hash_set <int, hash_compare <int, less<int> > > hs1;
   hash_set <int,  hash_compare <int, greater<int> > > hs2;
   hash_set <double, hash_compare <double,
      less<double> >, allocator<double> > hs3;

   hash_set <int, hash_compare <int,
      greater<int> > >::allocator_type hs2_Alloc;
   hash_set <double>::allocator_type hs3_Alloc;
   hs2_Alloc = hs2.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hs1.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hs3.max_size( ) <<  "." << endl;

   // The following lines create a hash_set hs4
   // with the allocator of hash_set hs1.
   hash_set <int>::allocator_type hs4_Alloc;
   hash_set <int> hs4;
   hs4_Alloc = hs2.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated by the other
   if( hs2_Alloc == hs4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_set::hash_set

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Tworzy element, który hash_set jest pusty lub jest kopią wszystkich lub części innych hash_setelementów .

hash_set();

explicit hash_set(
    const Traits& Comp);

hash_set(
    const Traits& Comp,
    const Allocator& Al);

hash_set(
    const hash_set<Key, Traits, Allocator>& Right);

hash_set(
    hash_set&& Right);

hash_set(
    initializer_list<Type> IList);

hash_set(
    initializer_list<Type> IList,
    const Compare& Comp);

hash_set(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al);

Parametry

Al
Klasa alokatora magazynu, która ma być używana dla tego hash_set obiektu, który domyślnie ma wartość Allocator.

Komp
Funkcja porównania typu const Traits używana do porządkowenia elementów w hash_setobiekcie , która jest domyślnie ustawiona na hash_compare.

Right
Element hash_set , którego konstrukcja hash_set ma być kopią.

Pierwszy
Położenie pierwszego elementu w zakresie elementów do skopiowania.

Ostatni
Położenie pierwszego elementu poza zakresem elementów do skopiowania.

Uwagi

Wszystkie konstruktory przechowują typ obiektu alokatora, który zarządza magazynem pamięci dla hash_set obiektu i które można później zwrócić przez wywołanie hash_set::get_allocator. Parametr alokatora jest często pomijany w deklaracjach klas i makrach przetwarzania wstępnego używanych do zastępowania alternatywnych alokatorów.

Wszystkie konstruktory inicjują swoje hash_sets.

Wszystkie konstruktory przechowują obiekt funkcji typu Traits , który jest używany do ustanowienia kolejności między kluczami elementu hash_set i które można później zwrócić przez wywołanie hash_set::key_comp. Aby uzyskać więcej informacji, Traits zobacz temat Klasa hash_set.

Pierwszy konstruktor tworzy pusty początkowy hash_set Drugi określa typ funkcji porównania ( Comp) do użycia w ustanawianiu kolejności elementów, a trzeci jawnie określa typ alokatora ( Al). Słowo explicit kluczowe pomija niektóre rodzaje automatycznej konwersji typów.

Czwarte i piąte konstruktory określają kopię elementu hash_set Right.

Ostatnie szóste, siódme i ósme konstruktory używają initializer_list dla elementów.

Ostatnie konstruktory kopiują zakres [ First, Last) hash_set obiektu z rosnącą jawnością w określaniu typu funkcji porównania cech klasy i alokatora.

Ósmy konstruktor przenosi element hash_set Right.

Rzeczywista kolejność elementów w hash_set kontenerze zależy od funkcji skrótu, funkcji porządkowania i bieżącego rozmiaru tabeli skrótów i nie można ogólnie przewidzieć, jak to możliwe w przypadku kontenera set, gdzie została określona tylko przez funkcję porządkowania.

hash_set::insert

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Wstawia element lub zakres elementów do elementu hash_set.

pair<iterator, bool> insert(
    const value_type& Val);

iterator insert(
    iterator Where,
    const value_type& Val);

void insert(
    initializer_list<value_type> IList)
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

Parametry

Val
Wartość elementu, który ma zostać wstawiony do hash_set elementu , chyba że hash_set element zawiera już ten element lub, ogólniej, element, którego klucz jest równoważnie uporządkowany.

Gdzie
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania. (Wstawienie może wystąpić w amortyzowanym stałym czasie, a nie w czasie logarytmicznych, jeśli punkt wstawiania natychmiast następuje _Where).)

Pierwszy
Pozycja pierwszego elementu, który ma zostać skopiowany z elementu hash_set.

Ostatni
Pozycja tuż poza ostatnim elementem, który ma zostać skopiowany z elementu hash_set.

IList
Lista initializer_list, z której mają być skopiowane elementy.

Wartość zwracana

insert Pierwsza funkcja składowa zwraca parę, której bool składnik zwracatrue, jeśli wstawienie zostało wprowadzone, a false jeśli hash_set już zawierał element, którego klucz miał równoważną wartość w kolejności, i którego składnik iteratora zwraca adres, w którym wstawiono nowy element lub gdzie element został już zlokalizowany.

Aby uzyskać dostęp do składnika iteratora pary pr zwróconej przez tę funkcję składową, użyj polecenia pr.first i , aby go wyłuszczyć, użyj polecenia *(pr.first). Aby uzyskać dostęp do bool składnika pary pr zwróconej przez tę funkcję składową, użyj polecenia pr.secondi , aby go wyłuszczyć, użyj polecenia *(pr.second).

insert Druga funkcja składowa zwraca iterator wskazujący położenie, w którym nowy element został wstawiony do elementu hash_set.

Uwagi

Trzecia funkcja składowa wstawia elementy w initializer_list.

Trzecia funkcja składowa wstawia sekwencję wartości elementów do hash_set odpowiadającego każdemu elementowi adresowanemu przez iterator w zakresie [ First, Last) określonego hash_setelementu .

hash_set::iterator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować dowolny element w hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

Uwagi

iterator Typ może służyć do modyfikowania wartości elementu.

Przykład

Zobacz przykład, aby zapoznać się z przykładem sposobu deklarowania i używania elementu iterator.

hash_set::key_comp

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Pobiera kopię obiektu cech skrótu używanego do określania wartości klucza skrótu i porządkowanie ich w hash_set.

key_compare key_comp() const;

Wartość zwracana

Zwraca obiekt funkcji, którego hash_set używa do zamawiania jego elementów, czyli parametru template Traits.

Aby uzyskać więcej informacji na temat cech , zobacz temat Hash_set Class (Klasa hash_set).

Uwagi

Przechowywany obiekt definiuje funkcję składową:

bool operator( const Key& _xVal, const Key& _yVal );

wartość , która zwraca wartość true , jeśli _xVal jest poprzednia i nie jest równa _yVal w kolejności sortowania.

Należy pamiętać, że zarówno key_compare, jak i value_compare są synonimami cech parametru szablonu. Oba typy są udostępniane dla klas hash_set i hash_multiset, w których są identyczne, w celu zachowania zgodności z klasami hash_map i hash_multimap, gdzie są one odrębne.

Przykład

// hash_set_key_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int, hash_compare < int, less<int> > >hs1;
   hash_set<int, hash_compare < int, less<int> > >::key_compare kc1
          = hs1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of hs1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of hs1."
        << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::key_compare
         kc2 = hs2.key_comp( ) ;
   bool result2 = kc2( 2, 3 ) ;
   if(result2 == true)
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of hs2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of hs2."
           << endl;
   }
}

hash_set::key_compare

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który udostępnia obiekt funkcji, który może porównać dwa klucze sortowania w celu określenia względnej kolejności dwóch elementów w hash_set.

typedef Traits key_compare;

Uwagi

key_comparejest synonimem cech parametru szablonu.

Aby uzyskać więcej informacji na temat cech , zobacz temat Hash_set Class (Klasa hash_set).

Należy pamiętać, że zarównokey_compare, jak i value_compare są synonimami cech parametru szablonu. Oba typy są udostępniane dla klas zestawów i wielu zestawów, w których są identyczne, w celu zachowania zgodności z klasami mapy i multimap, gdzie są one odrębne.

Przykład

Zobacz przykład key_comp, aby zapoznać się z przykładem sposobu deklarowania i używania elementu key_compare.

hash_set::key_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który opisuje obiekt przechowywany jako element hash_set w jego pojemności jako klucz sortowania.

typedef Key key_type;

Uwagi

key_typejest synonimem klucza parametru szablonu.

Aby uzyskać więcej informacji na temat klucza, zobacz sekcję Uwagi w temacie hash_set Class (Klasa hash_set).

Należy pamiętać, że zarównokey_type, jak i value_type są synonimami klucza parametru szablonu. Oba typy są udostępniane dla klas hash_set i hash_multiset, w których są identyczne, w celu zachowania zgodności z klasami hash_map i hash_multimap, gdzie są one odrębne.

Przykład

Zobacz przykład value_type, aby zapoznać się z przykładem sposobu deklarowania i używania elementu key_type.

hash_set::lower_bound

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator do pierwszego elementu w hash_set z kluczem równym lub większym niż określony klucz.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametry

key
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego hash_set.

Wartość zwracana

Element iterator lub const_iterator adresujący lokalizację elementu w hash_set, który ma klucz równy lub większy niż klucz argumentu lub który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_set, jeśli nie zostanie znalezione dopasowanie klucza.

Uwagi

Przykład

// hash_set_lower_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.lower_bound( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key of 40 is: "
           << *hs1_RcIter << "." << endl;

   // An element at a specific location in the hash_set can be found
   // by using a dereferenced iterator that addresses the location
   hs1_AcIter = hs1.end( );
   hs1_AcIter--;
   hs1_RcIter = hs1.lower_bound( *hs1_AcIter );
   cout << "The element of hs1 with a key matching "
        << "that of the last element is: "
        << *hs1_RcIter << "." << endl;
}

The element of hash_set hs1 with a key of 20 is: 20.
The hash_set hs1 doesn't have an element with a key of 40.
The element of hs1 with a key matching that of the last element is: 30.

hash_set::max_size

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca maksymalną długość hash_set.

size_type max_size() const;

Wartość zwracana

Maksymalna możliwa długość hash_set.

Uwagi

Przykład

// hash_set_max_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::size_type i;

   i = hs1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_set is " << i << "." << endl;
}

hash_set::operator=

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zastępuje elementy hash_set kopią innego hash_set.

hash_set& operator=(const hash_set& right);

hash_set& operator=(hash_set&& right);

Parametry

Prawy
Hash_set kopiowane do pliku hash_set.

Uwagi

Po wymazaniu wszystkich istniejących elementów w obiekcie hash_setoperator= , kopiuje lub przenosi zawartość bezpośrednio do obiektu hash_set.

Przykład

// hash_set_operator_as.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<int> v1, v2, v3;
   hash_set<int>::iterator iter;

   v1.insert(10);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter << " ";
   cout << endl;
}

hash_set::p ointer

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który dostarcza wskaźnik do elementu w hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::pointer pointer;

Uwagi

pointer Typ może służyć do modyfikowania wartości elementu.

W większości przypadków iterator powinien służyć do uzyskiwania dostępu do elementów w obiekcie hash_set.

hash_set::rbegin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator odnoszący się do pierwszego elementu w odwróconej hash_set.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu w odwróconej hash_set lub odnoszący się do tego, co było ostatnim elementem w niereversed hash_set.

Uwagi

rbegin jest używany z odwróconym hash_set tak samo jak początek jest używany z hash_set.

Jeśli wartość zwracana rbegin elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu hash_set. Jeśli wartość zwracana rbegin elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt hash_set.

rbegin może służyć do iterowania przez hash_set wstecz.

Przykład

// hash_set_rbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_rIter = hs1.rbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a hash_set in a forward order
   cout << "The hash_set is: ";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );
         hs1_Iter++ )
      cout << *hs1_Iter << " ";
   cout << endl;

   // rbegin can be used to start an iteration
   // through a hash_set in a reverse order
   cout << "The reversed hash_set is: ";
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );
         hs1_rIter++ )
      cout << *hs1_rIter << " ";
   cout << endl;

   // A hash_set element can be erased by dereferencing to its key
   hs1_rIter = hs1.rbegin( );
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_set is "<< *hs1_rIter << "."
        << endl;
}

The first element in the reversed hash_set is 30.
The hash_set is: 10 20 30
The reversed hash_set is: 30 20 10
After the erasure, the first element in the reversed hash_set is 20.

hash_set::reference

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który zawiera odwołanie do elementu przechowywanego w hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reference reference;

Uwagi

Przykład

// hash_set_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 10 );
   hs1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   int &Ref1 = *hs1.begin( );

   cout << "The first element in the hash_set is "
        << Ref1 << "." << endl;

   // The value of the 1st element of the hash_set can be changed
   // by operating on its (non-const) reference
   Ref1 = Ref1 + 5;

   cout << "The first element in the hash_set is now "
        << *hs1.begin() << "." << endl;
}

The first element in the hash_set is 10.
The first element in the hash_set is now 15.

hash_set::rend

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconej hash_set.

const_reverse_iterator rend() const;

reverse_iterator rend();

Wartość zwracana

Odwrotny iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym hash_set (lokalizacja, która poprzedzała pierwszy element w niereversedowanym hash_set).

Uwagi

rend jest używany z odwróconym hash_set tak samo jak koniec jest używany z hash_set.

Jeśli wartość zwracana rend elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu hash_set. Jeśli wartość zwracana rend elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt hash_set. Wartość zwracana przez rend nie powinna być wyłuszczone.

rend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec hash_set.

Przykład

// hash_set_rend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a hash_set in a forward order
   cout << "The hash_set is: ";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );
         hs1_Iter++ )
      cout << *hs1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a hash_set in a reverse order
   cout << "The reversed hash_set is: ";
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );
         hs1_rIter++ )
      cout << *hs1_rIter << " ";
   cout << "." << endl;

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "After the erasure, the last element in the "
        << "reversed hash_set is " << *hs1_rIter << "."
        << endl;
}

The last element in the reversed hash_set is 10.
The hash_set is: 10 20 30 .
The reversed hash_set is: 30 20 10 .
After the erasure, the last element in the reversed hash_set is 20.

hash_set::reverse_iterator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować element w odwróconej hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

Uwagi

Typ reverse_iterator służy do iterowania hash_set odwrotnie.

Przykład

Zobacz przykład dla narzędzia rbegin , aby zapoznać się z przykładem sposobu deklarowania i używania elementu reverse_iterator.

hash_set::size

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca liczbę elementów w hash_set.

size_type size() const;

Wartość zwracana

Bieżąca długość hash_set.

Uwagi

Przykład

// hash_set_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: size_type i;

   hs1.insert( 1 );
   i = hs1.size( );
   cout << "The hash_set length is " << i << "." << endl;

   hs1.insert( 2 );
   i = hs1.size( );
   cout << "The hash_set length is now " << i << "." << endl;
}

The hash_set length is 1.
The hash_set length is now 2.

hash_set::size_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Niepodpisany typ liczb całkowitych, który może reprezentować liczbę elementów w hash_set.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::size_type size_type;

Uwagi

Przykład

Zobacz przykład rozmiaru, aby zapoznać się z przykładem sposobu deklarowania i używaniasize_type

hash_set::swap

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Wymienia elementy dwóch hash_sets.

void swap(hash_set& right);

Parametry

Prawy
Argument hash_set dostarczający elementy, które mają zostać zamienione na hash_set docelową.

Uwagi

Funkcja składowa unieważnia żadne odwołania, wskaźniki lub iteratory, które wyznaczają elementy w dwóch hash_sets, których elementy są wymieniane.

Przykład

// hash_set_swap.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2, hs3;
   hash_set <int>::iterator hs1_Iter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );
   hs2.insert( 100 );
   hs2.insert( 200 );
   hs3.insert( 300 );

   cout << "The original hash_set hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   hs1.swap( hs2 );

   cout << "After swapping with hs2, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hs1, hs3 );

   cout << "After swapping with hs3, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;
}

The original hash_set hs1 is: 10 20 30.
After swapping with hs2, list hs1 is: 200 100.
After swapping with hs3, list hs1 is: 300.

hash_set::upper_bound

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Zwraca iterator do pierwszego elementu w hash_set, który ma klucz większy niż określony klucz.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametry

key
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego hash_set.

Wartość zwracana

Obiekt iterator lub const_iterator adresujący lokalizację elementu w hash_set, który ma klucz równy lub większy niż klucz argumentu, lub który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_set, jeśli nie zostanie znalezione dopasowanie klucza.

Uwagi

Przykład

// hash_set_upper_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "The first element of hash_set hs1 with a key greater "
        << "than 20 is: " << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key greater than 30." << endl;
   else
      cout << "The element of hash_set hs1 with a key > 40 is: "
           << *hs1_RcIter << "." << endl;

   // An element at a specific location in the hash_set can be found
   // by using a dereferenced iterator addressing the location
   hs1_AcIter = hs1.begin( );
   hs1_RcIter = hs1.upper_bound( *hs1_AcIter );
   cout << "The first element of hs1 with a key greater than "
        << endl << "that of the initial element of hs1 is: "
        << *hs1_RcIter << "." << endl;
}

The first element of hash_set hs1 with a key greater than 20 is: 30.
The hash_set hs1 doesn't have an element with a key greater than 30.
The first element of hs1 with a key greater than
that of the initial element of hs1 is: 20.

hash_set::value_comp

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Pobiera kopię obiektu porównania używanego do porządkowenia wartości elementów w hash_set.

value_compare value_comp() const;

Wartość zwracana

Zwraca obiekt funkcji używany przez hash_set w celu uporządkowania jego elementów, czyli parametru szablonu Compare.

Aby uzyskać więcej informacji na temat porównywania, zobacz sekcję Uwagi w temacie hash_set Class (Klasa hash_set).

Uwagi

Przechowywany obiekt definiuje funkcję składową:

bool operator( const Key& _xVal, const Key& _yVal );

wartość , która zwraca wartość true , jeśli _xVal jest poprzednia i nie jest równa _yVal w kolejności sortowania.

Należy pamiętać, że zarówno value_compare, jak i key_compare są synonimami parametru szablonu Compare. Oba typy są udostępniane dla klas hash_set i hash_multiset, w których są identyczne, w celu zachowania zgodności z klasami hash_map i hash_multimap, gdzie są one odrębne.

Przykład

// hash_set_value_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int, hash_compare < int, less<int> > > hs1;
   hash_set <int, hash_compare < int, less<int> >  >::value_compare
      vc1 = hs1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of hs1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of hs1."
           << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::value_compare
      vc2 = hs2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of hs2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of hs2."
           << endl;
   }
}

hash_set::value_compare

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który udostępnia dwa obiekty funkcji, binarny predykat klasy porównywania, który może porównać dwie wartości elementów hash_set w celu określenia ich względnej kolejności i jednoargumentowego predykatu, który skróty elementów.

typedef key_compare value_compare;

Uwagi

value_comparejest synonimem cech parametru szablonu.

Aby uzyskać więcej informacji na temat cech , zobacz temat Hash_set Class (Klasa hash_set).

Należy pamiętać, że zarówno key_compare, jak i value_compare są synonimami cech parametru szablonu. Oba typy są udostępniane dla klas hash_set i hash_multiset, w których są identyczne, w celu zachowania zgodności z klasami hash_map i hash_multimap, gdzie są one odrębne.

Przykład

Zapoznaj się z przykładem value_comp, aby zapoznać się z przykładem sposobu deklarowania i używania elementu value_compare.

hash_set::value_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_set.

Typ, który opisuje obiekt przechowywany jako element hash_set w jego pojemności jako wartość.

typedef Key value_type;

Przykład

// hash_set_value_type.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;

   hash_set <int> :: value_type hsvt_Int;   // Declare value_type
   hsvt_Int = 10;             // Initialize value_type

   hash_set <int> :: key_type hskt_Int;   // Declare key_type
   hskt_Int = 20;             // Initialize key_type

   hs1.insert( hsvt_Int );         // Insert value into hs1
   hs1.insert( hskt_Int );         // Insert key into hs1

   // A hash_set accepts key_types or value_types as elements
   cout << "The hash_set has elements:";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( ); hs1_Iter++)
      cout << " " << *hs1_Iter;
   cout << "." << endl;
}

The hash_set has elements: 10 20.

Zobacz też

Bezpieczeństwo wątku w standardowej bibliotece C++
Dokumentacja standardowej biblioteki C++

Udostępnij za pośrednictwem

hash_set — Klasa

Składnia

Parametry

Uwagi

Konstruktory

Typedefs

Funkcje składowe

Operatory

Wymagania

hash_set::allocator_type

Uwagi

Przykład

hash_set::begin

Wartość zwracana

Uwagi

Przykład

hash_set::cbegin

Wartość zwracana

Uwagi

Przykład

hash_set::cend

Wartość zwracana

Uwagi

Przykład

hash_set::clear

Uwagi

Przykład

hash_set::const_iterator

Uwagi

Przykład

hash_set::const_pointer

Uwagi

hash_set::const_reference

Uwagi

Przykład

hash_set::const_reverse_iterator

Uwagi

Przykład

hash_set::count

Parametry

Wartość zwracana

Uwagi

Przykład

hash_set::crbegin

Wartość zwracana

Uwagi

Przykład

hash_set::crend

Wartość zwracana

Uwagi

Przykład

hash_set::d ifference_type

Uwagi

Przykład

hash_set::emplace

Parametry

Wartość zwracana

Uwagi

Przykład

hash_set::emplace_hint

Parametry

Wartość zwracana

Uwagi

Przykład

hash_set::empty

Wartość zwracana

Uwagi

Przykład

hash_set::end

Wartość zwracana

Uwagi

Przykład

hash_set::equal_range

Parametry

Wartość zwracana

Uwagi

Przykład

hash_set::erase

Parametry