hash_set – třída

Článek
07/05/2024

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Třída kontejneru hash_set je rozšíření standardní knihovny jazyka C++ a slouží k ukládání a rychlému načítání dat z kolekce, ve které jsou hodnoty obsažených prvků jedinečné a slouží jako klíčové hodnoty.

Syntaxe

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

Parametry

Klíč
Datový typ prvku, který má být uložen v hash_set.

Rysy
Typ, který obsahuje dva objekty funkce, jeden z porovnání tříd, který je binární predikát schopen porovnat dvě hodnoty prvků jako klíče řazení k určení jejich relativního pořadí a hash funkce, která je unární predikát mapující klíčové hodnoty prvků na nepodepsané celá čísla typu size_t. Tento argument je nepovinný a jedná se hash_compare<Key, less<Key> > o výchozí hodnotu.

Alokátor
Typ, který představuje uložený objekt alokátoru, který zapouzdřuje podrobnosti o přidělení hash_set a uvolnění paměti. Tento argument je nepovinný a výchozí hodnota je allocator<Key>.

Poznámky

Hash_set je:

Asociativní kontejner, což je kontejner proměnné velikosti, který podporuje efektivní načtení hodnoty prvku založené na přiřazené hodnotě klíče. Dále je to jednoduchý asociativní kontejner, protože jeho hodnoty prvku jsou jeho hodnoty klíče.
Oboustranný, protože poskytuje obousměrný iterátor pro přístup k jeho prvkům.
Hodnota hash, protože její prvky jsou seskupeny do kbelíků na základě hodnoty hash funkce použité na klíčové hodnoty prvků.
Jedinečný v tom smyslu, že každý z jeho prvků musí mít jedinečný klíč. Protože hash_set je také jednoduchý asociativní kontejner, jeho prvky jsou také jedinečné.
Šablona třídy, protože funkce, které poskytuje, je obecná a tak nezávislá na konkrétním typu dat obsažených jako prvky nebo klíče. Datové typy použité pro prvky a klíče jsou místo toho zadány jako parametry v šabloně třídy společně s funkcí porovnání a alokátorem.

Hlavní výhodou hashování při řazení je větší efektivita; Úspěšné zatřiďování provádí vkládání, odstraňování a hledání v konstantním průměrném čase ve srovnání s časem úměrným logaritmu počtu prvků v kontejneru pro techniky řazení. Hodnotu prvku v sadě nelze změnit přímo. Místo toho musíte odstranit staré hodnoty a vložit prvky s novými hodnotami.

Volba typu kontejneru by měla obecně vycházet z typu vyhledávání a vkládání vyžadovaného aplikací. Asociativní kontejnery s hodnotou hash jsou optimalizované pro operace vyhledávání, vkládání a odebírání. Členské funkce, které explicitně podporují tyto operace, jsou efektivní při použití s dobře navrženou hashovací funkcí, provádějí je v čase, který je v průměrné konstantě a není závislý na počtu prvků v kontejneru. Dobře navržená funkce hash vytváří jednotnou distribuci hodnot hash a minimalizuje počet kolizí, kdy ke kolizi dochází, když se jedinečné hodnoty klíče mapují na stejnou hodnotu hash. V nejhorším případě s nejhorší možnou hashovou funkcí je počet operací úměrný počtu prvků v sekvenci (lineární čas).

Hash_set by měla být asociativním kontejnerem podle výběru, pokud aplikace splňuje podmínky asociující hodnoty s jejich klíči. Prvky hash_set jsou jedinečné a slouží jako vlastní klíče řazení. Model pro tento typ struktury je uspořádaný seznam slov, v němž se slova mohou vyskytovat pouze jednou. Pokud bylo povoleno více výskytů slov, pak by hash_multiset byla vhodná struktura kontejneru. Pokud je potřeba hodnoty připojit k seznamu jedinečných klíčových slov, pak by hash_map byla vhodná struktura, která by tato data obsahovala. Pokud místo toho klíče nejsou jedinečné, pak hash_multimap by byl kontejner, který je volbou.

Hash_set pořadí určuje pořadí, které řídí voláním uloženého objektu hash Traits typu value_compare. K tomuto uloženému objektu může přistupovat voláním členské funkce key_comp. Takový objekt funkce se musí chovat stejně jako objekt třídy hash_compare<Klíč, menší<Klíč>>. Konkrétně pro všechny hodnoty key typu Klíč vrátí volání Trait(key) rozdělení hodnot typu size_t.

Obecně, tyto prvky musí být menší než srovnatelné pro toto pořadí, což znamená, že když jsou uvedeny dva prvky, může být stanoveno, zda jsou ekvivalentní (v tom smyslu, že ani jeden není menší než ten druhý), nebo že jeden je menší než druhý. Výsledkem je řazení mezi nerovnaným elementem. Technicky je funkce porovnání binárním predikátem, který indukuje přísné slabé řazení, standardním matematickým způsobem. Binární predikát f( x; y) je objekt funkce, který má dva argumentové objekty x a y a návratovou hodnotu true nebo false. Řazení uložené na hash_set je striktní slabé řazení, pokud je binární predikát neflexivní, antisymetrické a tranzitivní a pokud je ekvivalence tranzitivní, kde jsou dva objekty x a y definovány jako ekvivalentní, pokud jsou oba f( x, y) a f( y, x) nepravdivé. Pokud silnější podmínka rovnosti mezi klíči nahradí ekvivalenci, stane se pořadí celkovým (v tom smyslu, že všechny prvky jsou uspořádány ve vztahu k sobě navzájem) a odpovídající klíče budou od sebe nerozeznatelné.

Skutečné pořadí prvků v řízené sekvenci závisí na funkci hash, funkci řazení a aktuální velikosti tabulky hash uložené v objektu kontejneru. Aktuální velikost tabulky hash nelze určit, takže obecně nelze předpovědět pořadí prvků v řízené sekvenci. Vkládání prvků nezruší platnost žádných iterátorů a odstranění prvků zruší platnost pouze těch iterátorů, které výslovně odkazovaly na odstraněné prvky.

Iterátor poskytovaný hash_set třída je obousměrný iterátor, ale členské funkce třídy vkládají a hash_set mají verze, které berou jako parametry šablony slabší vstupní iterátor, jehož požadavky na funkčnost jsou více minimální než ty, které zaručuje třída obousměrných iterátorů. Různé koncepty iterátorů tvoří rodinu týkající se upřesnění jejich funkčnosti. Každý koncept iterátoru má vlastní sadu požadavků a algoritmy, které s nimi pracují, musí omezit jejich předpoklady na požadavky podle typu iterátoru. Lze předpokládat, že ke vstupnímu iterátoru lze přistoupit přes ukazatel pro odkazování na některý objekt a že může být zvýšen na další iterátor v pořadí. Jedná se o minimální sadu funkcí, ale stačí, abyste mohli smysluplně mluvit o rozsahu iterátorů [ , firstlast) v kontextu členské funkce třídy.

Konstruktory

Konstruktor	Popis
hash_set	`hash_set` Vytvoří, která je prázdná nebo která je kopií všech nebo částí jiného `hash_set`.

Typedefs

Název typu	Popis
allocator_type	Typ, který představuje `allocator` třídu objektu `hash_set` .
const_iterator	Typ, který poskytuje obousměrný iterátor, který může číst `const` prvek v objektu `hash_set`.
const_pointer	Typ, který poskytuje ukazatel na `const` prvek v objektu `hash_set`.
const_reference	Typ, který poskytuje odkaz na `const` prvek uložený v objektu `hash_set` pro čtení a provádění `const` operací.
const_reverse_iterator	Typ, který poskytuje obousměrný iterátor, který může číst libovolný `const` prvek v objektu `hash_set`.
difference_type	Typ celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků `hash_set` v rozsahu mezi prvky, na které odkazují iterátory.
iterátor	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat libovolný prvek v objektu `hash_set`.
key_compare	Typ, který poskytuje objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v objektu `hash_set`.
key_type	Typ, který popisuje objekt uložený jako prvek `hash_set` ve své kapacitě jako klíč řazení.
ukazatel	Typ, který poskytuje ukazatel na prvek v objektu `hash_set`.
odkaz	Typ, který poskytuje odkaz na prvek uložený v objektu `hash_set`.
reverse_iterator	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném směru `hash_set`.
size_type	Typ celého čísla bez znaménka, který může představovat počet prvků v objektu `hash_set`.
value_compare	Typ, který poskytuje dva objekty funkce, binární predikát třídy porovnání, který může porovnat dvě hodnoty prvku a `hash_set` určit jejich relativní pořadí a unární predikát, který hashuje prvky.
value_type	Typ, který popisuje objekt uložený jako prvek `hash_set` ve své kapacitě jako hodnotu.

Členské funkce

Členová funkce	Popis
začít	Vrátí iterátor, který řeší první prvek v objektu `hash_set`.
cbegin	Vrátí konstantní iterátor adresování prvního prvku v objektu `hash_set`.
cend	Vrátí iterátor const, který řeší umístění úspěšné poslední prvek v objektu `hash_set`.
jasný	Vymaže všechny prvky .`hash_set`
count	Vrátí počet prvků v `hash_set` klíči, jehož klíč odpovídá klíči zadanému parametrem.
crbegin	Vrátí konstantní iterátor adresovaný prvním prvkem v obráceném směru `hash_set`.
crend	Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obráceném `hash_set`stavu .
umístit	Vloží prvek vytvořený na místě do objektu `hash_set`.
emplace_hint	Vloží prvek vytvořený na místě do objektu `hash_set`, s tipem umístění.
empty	Testuje, jestli `hash_set` je prázdný.
konec	Vrátí iterátor, který řeší umístění úspěšné poslední prvek v objektu `hash_set`.
equal_range	Vrátí dvojici iterátorů v uvedeném pořadí k prvnímu prvku v `hash_set` klíči, který je větší než zadaný klíč, a k prvnímu prvku v `hash_set` klíči, který je roven nebo větší než klíč.
vymazat	Odebere prvek nebo rozsah prvků v `hash_set` zadané pozici nebo odebere prvky, které odpovídají zadanému klíči.
find	Vrátí iterátor adresovaný umístění prvku v objektu `hash_set` , který má klíč ekvivalentní zadanému klíči.
get_allocator	Vrátí kopii objektu `allocator` použitého k vytvoření objektu `hash_set`.
vložit	Vloží prvek nebo oblast prvků do objektu `hash_set`.
key_comp	Načte kopii objektu porovnání použitého k řazení klíčů v objektu `hash_set`.
lower_bound	Vrátí iterátor na první prvek v klíči `hash_set` , který je roven nebo větší než zadaný klíč.
max_size	Vrátí maximální délku `hash_set`.
Rbegin	Vrátí iterátor adresovaný prvním prvkem v obráceném směru `hash_set`.
rvát	Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu `hash_set`.
velikost	Vrátí počet prvků v sadě `hash_set`.
vyměnit	Vymění prvky dvou `hash_set`s.
upper_bound	Vrátí iterátor na první prvek v objektu `hash_set` s klíčem, který je roven nebo větší než zadaný klíč.
value_comp	Načte kopii objektu hash vlastnosti použitého k hodnotě hash a pořadí hodnot klíče elementu v objektu `hash_set`.

Operátory

Operátor	Popis
hash_set::operator=	Nahradí prvky jiného `hash_set` souboru kopií jiného `hash_set`.

Požadavky

Header:<hash_set>

Obor názvů: stdext

hash_set::allocator_type

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který představuje alokátor třídy pro hash_set objektu.

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

Poznámky

allocator_type je synonymem parametru šablony Allocator.

Další informace o alokátoru naleznete v části Poznámky tématu hash_set Třída .

Příklad

Příklad get_allocator příkladu, který používá allocator_type.

hash_set::begin

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí iterátor, který řeší první prvek v hash_set.

const_iterator begin() const;

iterator begin();

Návratová hodnota

Obousměrný iterátor adresující první prvek v hash_set nebo umístění úspěšné prázdné hash_set.

Poznámky

Pokud je vrácená hodnota begin přiřazena k objektu const_iterator, nelze prvky v objektu hash_set změnit. Pokud je vrácená hodnota begin přiřazena k objektu iterator, lze upravit prvky v hash_set objektu.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí iterátor const, který řeší první prvek v hash_set.

const_iterator cbegin() const;

Návratová hodnota

Obousměrný iterátor adresující první prvek v hash_set nebo umístění úspěšné prázdné hash_set.

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v objektu hash_set .

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v hash_set.

const_iterator cend() const;

Návratová hodnota

Const obousměrný iterátor, který řeší umístění úspěšné poslední prvek v hash_set. hash_set Pokud je prázdný, pak hash_set::cend == hash_set::begin.

Poznámky

cend slouží k otestování, zda iterátor dosáhl konce jeho hash_set. Hodnota vrácená cend hodnotou by neměla být dereferenced.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vymaže všechny prvky hash_set.

void clear();

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje obousměrný iterátor, který může číst const prvek v hash_set.

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

Poznámky

Typ const_iterator nelze použít k úpravě hodnoty prvku.

Příklad

Příklad pro začátek příkladu, který používá const_iterator.

hash_set::const_pointer

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje ukazatel na const prvek v hash_set.

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

Poznámky

Typ const_pointer nelze použít k úpravě hodnoty prvku.

Ve většině případů by se const_iterator měla použít pro přístup k prvkům v objektu const hash_set.

hash_set::const_reference

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje odkaz na const prvek uložený v hash_set pro čtení a provádění const operací.

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

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje obousměrný iterátor, který může číst libovolný const prvek v hash_set.

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

Poznámky

Typ const_reverse_iterator nemůže změnit hodnotu prvku a používá se k iteraci přes hash_set obráceně.

Příklad

Příklad verze najdete v příkladu deklarování a používáníconst_reverse_iterator

hash_set::count

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí počet prvků v hash_set, jejichž klíč odpovídá klíči zadanému parametrem.

size_type count(const Key& key) const;

Parametry

key
Klíč prvků, které se mají spárovat z hash_set.

Návratová hodnota

1, pokud hash_set obsahuje prvek, jehož klíč řazení odpovídá klíči parametru.

0, pokud hash_set neobsahuje prvek s odpovídajícím klíčem.

Poznámky

Členová funkce vrátí počet prvků v následujícím rozsahu:

[ lower_bound(klíč), upper_bound(klíč) ).

Příklad

Následující příklad ukazuje použití hash_set::count členské funkce.

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí konstantní iterátor adresovaný prvním prvkem v obráceném hash_set.

const_reverse_iterator crbegin() const;

Návratová hodnota

Const reverse obousměrný iterátor adresovaný prvním prvkem v obráceném hash_set nebo adresování toho, co bylo posledním prvkem v nereverze hash_set.

Poznámky

crbegin se používá s obráceným hash_set stejně jako hash_set::begin se používá s hash_set.

S návratovou crbeginhodnotou objektu hash_set nelze změnit.

crbegin lze použít k iteraci zpět hash_set .

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obráceném hash_set.

const_reverse_iterator crend() const;

Návratová hodnota

Const reverse obousměrný iterátor, který řeší umístění úspěšné poslední prvek v obráceném hash_set (umístění, které předchází prvnímu prvku v nereverze hash_set).

Poznámky

crend se používá s obráceným hash_set kódem stejně jako hash_set::end se používá s parametrem hash_set.

S návratovou crendhodnotou objektu hash_set nelze změnit.

crend lze použít k otestování, zda reverzní iterátor dosáhl konce jeho hash_set.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků hash_set v rozsahu mezi prvky, na které odkazují iterátory.

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

Poznámky

Jedná se difference_type o typ vrácený při odečtení nebo zvýšení prostřednictvím iterátorů kontejneru. Obvykle difference_type se používá k reprezentaci počtu prvků v rozsahu [ first, last) mezi iterátory first a last, zahrnuje prvek, na který first odkazuje, a rozsah prvků až do, ale nikoli včetně, prvek, na který lastodkazuje .

Všimněte si, že ačkoli difference_type je k dispozici pro všechny iterátory, které splňují požadavky vstupního iterátoru, který zahrnuje třídu obousměrných iterátorů podporovaných reverzibilními kontejnery, jako je sada, odčítání mezi iterátory je podporováno pouze iterátory náhodného přístupu poskytované kontejnerem náhodného přístupu, jako je vektor nebo deque.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vloží prvek vytvořený na místě do hash_set.

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

Parametry

Val
Hodnota prvku, který má být vložen do hash_set , pokud hash_set již tento prvek neobsahuje nebo obecně prvek, jehož klíč je ekvivalentně seřazen.

Návratová hodnota

Členová emplace funkce vrátí dvojici, jejíž bool součást vrátí true hodnotu vložení, a false pokud hash_set již obsahoval prvek, jehož klíč měl ekvivalentní hodnotu v pořadí, a jehož iterátorová komponenta vrátí adresu, kde byl vložen nový prvek nebo kde byl prvek již umístěn.

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vloží prvek vytvořený na místě do hash_set.

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

Parametry

Val
Hodnota prvku, který má být vložen do hash_set , pokud hash_set již tento prvek neobsahuje nebo obecně prvek, jehož klíč je ekvivalentně seřazen.

_Kde
Místo zahájení vyhledání správného bodu vložení. (Vložení může nastat v amortizovaném konstantním čase místo logaritmického času, pokud kurzor bezprostředně následuje _Where.)

Návratová hodnota

Členová funkce hash_set::emplace vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do objektu hash_set, nebo kde je umístěn existující prvek s ekvivalentním řazením.

Poznámky

Vložení může nastat v amortizovaném konstantním čase místo logaritmického času, pokud kurzor bezprostředně následuje _Where.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Testuje, jestli je hash_set prázdný.

bool empty() const;

Návratová hodnota

true je-li hash_set prázdná; false pokud je hash_set nechtěná.

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí iterátor adresující umístění úspěšného posledního prvku v hash_set.

const_iterator end() const;

iterator end();

Návratová hodnota

Obousměrný iterátor, který řeší umístění úspěšné poslední prvek v hash_set. Pokud je hash_set prázdný, hash_set::end == hash_set::begin.

Poznámky

end slouží k otestování, zda iterátor dosáhl konce hash_set. Hodnota vrácená end hodnotou by neměla být dereferenced.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí dvojici iterátorů s prvním prvkem v sadě hash s klíčem, který se rovná zadanému klíči, a prvnímu prvku v sadě hash s klíčem, který je větší než klíč.

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

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

Parametry

key
Klíč argumentu, který se má porovnat s klíčem řazení prvku z prohledávaného hash_set.

Návratová hodnota

Dvojice iterátorů, kde první je lower_bound klíče a druhý je upper_bound klíče.

Pokud chcete získat přístup k prvnímu iterátoru párové žádosti vrácené členovou funkcí, použijte pr. nejprve a chcete-li odvodit dolní mez iterátoru, použijte *( pr. první). Pokud chcete získat přístup k druhému iterátoru dvojice pr vrácené členovou funkcí, použijte pr. a chcete-li převést horní mez iterátoru, použijte *( pr. druhý).

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Odebere prvek nebo rozsah prvků v hash_set ze zadaných pozic nebo odebere prvky, které odpovídají zadanému klíči.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parametry

_Kde
Pozice prvku, který má být odebrán z hash_set.

první
Pozice prvního prvku odebraného z hash_set

poslední
Umístění těsně za posledním prvkem odebranými z hash_set

key
Klíč prvků, které mají být odebrány z hash_set.

Návratová hodnota

Pro první dvě členské funkce obousměrný iterátor, který určuje první prvek, který zůstává nad všemi odebranými prvky, nebo ukazatel na konec hash_set pokud takový prvek neexistuje. U třetí členské funkce je počet prvků odebraných z hash_set.

Poznámky

Členské funkce nikdy nevyvolají výjimku.

Příklad

Následující příklad ukazuje použití hash_set::erase členské funkce.

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí iterátor adresovaný umístění prvku v hash_set, který má klíč ekvivalentní zadanému klíči.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Klíč argumentu, který se má shodovat s klíčem řazení prvku z prohledávaného hash_set.

Návratová hodnota

const_iterator Nebo iterator adresuje umístění prvku ekvivalentního zadanému klíči nebo adresuje umístění úspěšného posledního prvku v hash_set pokud se pro klíč nenajde žádná shoda.

Poznámky

Členská funkce vrátí iterátor, který řeší prvek v hash_set jehož klíč řazení je equivalent klíč argumentu pod binárním predikátem, který indukuje řazení na základě porovnání.

Pokud je vrácená hodnota find přiřazena k objektu const_iterator, nelze změnit objekt hash_set. Pokud je vrácená hodnota find přiřazena k objektu iterator, lze upravit hash_set objekt.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí kopii objektu alokátoru použitého k vytvoření hash_set.

Allocator get_allocator() const;

Návratová hodnota

Alokátor používaný hash_set ke správě paměti, což je parametr šablony Allocator.

Další informace o alokátoru naleznete v části Poznámky tématu hash_set Třída .

Poznámky

Alokátory pro třídu hash_set určují, jak třída spravuje úložiště. Výchozí alokátory dodávané s třídami kontejneru standardní knihovny C++ jsou dostatečné pro většinu programovacích potřeb. Psaní a používání vlastní třídy alokátoru je pokročilé téma jazyka C++.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

hash_set Vytvoří, která je prázdná nebo která je kopií všech nebo částí jiného hash_set.

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

Hliník
Třída alokátoru úložiště, která se má použít pro tento hash_set objekt, což je výchozí hodnota Allocator.

Comp
Porovnávací funkce typu const Traits , která se používá k seřazení prvků v hash_setsouboru , který je výchozí hash_compare.

Right
Z hash_set nichž vytvořený hash_set má být kopií.

První
Pozice prvního prvku v oblasti prvků, které se mají zkopírovat.

Poslední
Pozice prvního prvku nad rozsah prvků, které se mají zkopírovat.

Poznámky

Všechny konstruktory ukládají typ objektu alokátoru, který spravuje úložiště paměti pro objekt hash_set a který lze později vrátit voláním hash_set::get_allocator. Parametr allocator je často v deklaraci třídy vynechán a makra předběžného zpracování jsou použita k nahrazení alternativních alokátorů.

Všechny konstruktory inicializují jejich hash_sets.

Všechny konstruktory ukládají objekt funkce typu Traits , který se používá k vytvoření pořadí mezi klíči hash_set a které lze později vrátit voláním hash_set::key_comp. Další informace najdete v Traits tématu hash_set Třída .

První konstruktor vytvoří prázdný iniciála hash_set . Druhý určuje typ porovnávací funkce ( Comp) k určení pořadí prvků a třetí explicitně určuje typ alokátoru ( Al). Klíčové slovo explicit potlačí některé druhy automatického převodu typu.

Čtvrtý a pátý konstruktor určuje kopii hash_set Right.

Poslední šestý, sedmý a osmý konstruktor používají pro prvky initializer_list.

Poslední konstruktory zkopírují rozsah [ First, Last) hash_set s rostoucí explicitností při určení typu porovnávací funkce třídy Vlastnosti a alokátoru.

Osmý konstruktor přesune hash_set Right.

Skutečné pořadí prvků v kontejneru hash_set závisí na funkci hash, na funkci řazení a aktuální velikosti tabulky hash a obecně nelze předpovědět, jak by to mohlo být u kontejneru sady, kde byla určena samotnou funkcí řazení.

hash_set::insert

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vloží prvek nebo oblast prvků do objektu 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
Hodnota prvku, který má být vložen do objektu hash_set hash_set , pokud již tento prvek neobsahuje, nebo obecně prvek, jehož klíč je odpovídajícím způsobem seřazen.

Kde
Místo zahájení vyhledání správného bodu vložení. (Vložení může nastat v amortizovaném konstantním čase místo logaritmického času, pokud kurzor bezprostředně následuje _Where.)

První
Pozice prvního prvku, který se má zkopírovat z objektu hash_set.

Poslední
Pozice těsně za posledním prvkem, který se má zkopírovat z objektu hash_set.

IList
Seznam initializer_list, ze kterého chcete kopírovat prvky.

Návratová hodnota

První insert členová funkce vrátí dvojici, jejíž bool komponenta vrátí true , pokud byla vložena, a false pokud hash_set již obsahoval prvek, jehož klíč měl ekvivalentní hodnotu v pořadí, a jehož součást iterátoru vrátí adresu, kde byl vložen nový prvek nebo kde byl prvek již umístěn.

Pokud chcete získat přístup ke komponentě iterátoru dvojice pr vrácené touto členovou funkcí, použijte pr.first ji a k jejímu dereferenci použijte *(pr.first). Chcete-li získat přístup ke bool komponentě páru pr vrácené touto členovou funkcí, použijte pr.seconda k jeho dereferenci použijte *(pr.second).

Druhá insert členová funkce vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do hash_set.

Poznámky

Třetí člen funkce vloží prvky do initializer_list.

Třetí člen funkce vloží sekvenci hodnot prvků do hash_set odpovídajících prvků adresovaných iterátorem v rozsahu [ , FirstLast) zadaného hash_set.

hash_set::iterator

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat libovolný prvek v hash_set.

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

Poznámky

Typ iterator lze použít k úpravě hodnoty elementu.

Příklad

Podívejte se na příklad začátku příkladu, jak deklarovat a používat iterator.

hash_set::key_comp

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Načte kopii objektu hash traits sloužícího k hodnotě klíče elementu hash a pořadí v hash_set.

key_compare key_comp() const;

Návratová hodnota

Vrátí objekt funkce, který hash_set používá k seřazení jeho prvků, což je parametr šablony Traits.

Další informace o vlastnostech naleznete v tématu hash_set Třída .

Poznámky

Uložený objekt definuje členovu funkci:

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

vrátí true , pokud _xVal předchází a není roven _yVal v pořadí řazení.

Všimněte si, že key_compare i value_compare jsou synonyma pro vlastnosti parametru šablony. Oba typy jsou k dispozici pro třídy hash_set a hash_multiset, kde jsou identické, kvůli kompatibilitě s třídami hash_map a hash_multimap, kde jsou odlišné.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v hash_set.

typedef Traits key_compare;

Poznámky

key_compare je synonymem parametru šablony Traits.

Další informace o vlastnostech naleznete v tématu hash_set Třída .

Všimněte si, že key_compare value_compare jsou synonyma pro vlastnosti parametru šablony. Oba typy jsou k dispozici pro třídy množiny a více sad, kde jsou identické, kvůli kompatibilitě s mapou a vícemapovými třídami, kde jsou odlišné.

Příklad

Příklad key_comp příklad deklarování a použití key_compare.

hash_set::key_type

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který popisuje objekt uložený jako prvek hash_set ve své kapacitě jako klíč řazení.

typedef Key key_type;

Poznámky

key_typeje synonymem pro klíč parametru šablony.

Další informace o klíči naleznete v části Poznámky v tématu hash_set Třída .

Všimněte si, že key_type value_type jsou synonyma pro klíč parametru šablony. Oba typy jsou k dispozici pro třídy hash_set a hash_multiset, kde jsou identické, kvůli kompatibilitě s třídami hash_map a hash_multimap, kde jsou odlišné.

Příklad

Příklad value_type příklad deklarování a použití key_type.

hash_set::lower_bound

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí iterátor na první prvek v hash_set s klíčem, který je roven nebo větší než zadaný klíč.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametry

key
Klíč argumentu, který se má porovnat s klíčem řazení prvku z prohledávaného hash_set.

Návratová hodnota

const_iterator Nebo iterator adresující umístění prvku v hash_set, který se shoduje s klíčem, který je roven nebo větší než klíč argumentu nebo který řeší umístění úspěšné poslední prvek v hash_set, pokud se pro klíč nenajde žádná shoda.

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí maximální délku hash_set.

size_type max_size() const;

Návratová hodnota

Maximální možná délka hash_set.

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Nahradí prvky hash_set kopií jiného hash_set.

hash_set& operator=(const hash_set& right);

hash_set& operator=(hash_set&& right);

Parametry

Vpravo
Zkopírovaný hash_set do souboru hash_set.

Poznámky

Po vymazání všech existujících prvků v souboru hash_set, operator= buď zkopíruje nebo přesune obsah vpravo do hash_set.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje ukazatel na prvek v hash_set.

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

Poznámky

Typ pointer lze použít k úpravě hodnoty elementu.

Ve většině případů by měl být iterátor použit pro přístup k prvkům v objektu hash_set.

hash_set::rbegin

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí iterátor adresovaný prvním prvkem v obráceném hash_set.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Návratová hodnota

Reverzní obousměrný iterátor adresovaný prvním prvkem v obráceném hash_set nebo adresování toho, co bylo posledním prvkem v nereverzním hash_set.

Poznámky

rbegin se používá s obráceným hash_set stejně jako začátek se používá s hash_set.

Pokud je vrácená hodnota rbegin přiřazena k objektu const_reverse_iterator, nelze hash_set objekt změnit. Pokud je vrácená hodnota rbegin přiřazena k objektu reverse_iterator, lze upravit hash_set objekt.

rbegin lze použít k iteraci hash_set zpět.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje odkaz na prvek uložený v hash_set.

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

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném hash_set.

const_reverse_iterator rend() const;

reverse_iterator rend();

Návratová hodnota

Reverzní obousměrný iterátor, který řeší umístění úspěšné poslední prvek v obráceném hash_set (umístění, které předchází prvnímu prvku v nereverzním hash_set).

Poznámky

rend se používá s obráceným hash_set stejně jako konec se používá s hash_set.

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iterator, nelze hash_set objekt změnit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iterator, lze upravit hash_set objekt. Hodnota vrácená rend hodnotou by neměla být dereferenced.

rend lze použít k otestování, zda reverzní iterátor dosáhl konce hash_set.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném hash_set.

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

Poznámky

Typ reverse_iterator se používá k iteraci hash_set obráceně.

Příklad

Podívejte se na příklad pro rbegin příklad, jak deklarovat a používat reverse_iterator.

hash_set::size

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí počet prvků v hash_set.

size_type size() const;

Návratová hodnota

Aktuální délka hash_set.

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ celého čísla bez znaménka, který může představovat počet prvků v hash_set.

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

Poznámky

Příklad

Příklad deklarování a použití velikosti najdete v příkladu velikosti . size_type

hash_set::swap

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vymění prvky dvou hash_sets.

void swap(hash_set& right);

Parametry

Vpravo
Argument hash_set poskytnutí prvků, které se mají prohodit s cílovým hash_set.

Poznámky

Členová funkce zneplatňuje žádné odkazy, ukazatele nebo iterátory, které označují prvky ve dvou hash_sets jejichž prvky se vyměňují.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Vrátí iterátor na první prvek v hash_set, který s klíčem, který je větší než zadaný klíč.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametry

key
Klíč argumentu, který se má porovnat s klíčem řazení prvku z prohledávaného hash_set.

Návratová hodnota

const_iterator Nebo iterator adresuje umístění prvku v hash_set, který má klíč, který je roven nebo větší než klíč argumentu, nebo který řeší umístění úspěšného posledního prvku v hash_set pokud se pro klíč nenajde žádná shoda.

Poznámky

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Načte kopii objektu porovnání použitého k seřazení hodnot prvků v hash_set.

value_compare value_comp() const;

Návratová hodnota

Vrátí objekt funkce, který hash_set používá k seřazení jeho prvků, což je parametr šablony Compare.

Další informace o porovnání naleznete v části Poznámky v tématu hash_set Třída .

Poznámky

Uložený objekt definuje členovu funkci:

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

vrátí true , pokud _xVal předchází a není roven _yVal v pořadí řazení.

Všimněte si, že value_compare i key_compare jsou synonyma pro parametr šablony Compare. Oba typy jsou k dispozici pro třídy hash_set a hash_multiset, kde jsou identické, kvůli kompatibilitě s třídami hash_map a hash_multimap, kde jsou odlišné.

Příklad

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

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který poskytuje dva objekty funkce, binární predikát třídy porovnání, který může porovnat dvě hodnoty prvků hash_set určit jejich relativní pořadí a unární predikát, který hashuje prvky.

typedef key_compare value_compare;

Poznámky

value_compare je synonymem parametru šablony Traits.

Další informace o vlastnostech naleznete v tématu hash_set Třída .

Všimněte si, že key_compare i value_compare synonyma pro vlastnosti parametru šablony. Oba typy jsou k dispozici pro třídy hash_set a hash_multiset, kde jsou identické, kvůli kompatibilitě s třídami hash_map a hash_multimap, kde jsou odlišné.

Příklad

Příklad value_comp příklad deklarování a použití value_compare.

hash_set::value_type

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je třída unordered_set.

Typ, který popisuje objekt uložený jako prvek hash_set ve své kapacitě jako hodnotu.

typedef Key value_type;

Příklad

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

Viz také

Bezpečný přístup z více vláken ve standardní knihovně C++
Standardní knihovna C++ – referenční dokumentace

Sdílet prostřednictvím

hash_set – třída

Syntaxe

Parametry

Poznámky

Konstruktory

Typedefs

Členské funkce

Operátory

Požadavky

hash_set::allocator_type

Poznámky

Příklad

hash_set::begin

Návratová hodnota

Poznámky

Příklad

hash_set::cbegin

Návratová hodnota

Poznámky

Příklad

hash_set::cend

Návratová hodnota

Poznámky

Příklad

hash_set::clear

Poznámky

Příklad

hash_set::const_iterator

Poznámky

Příklad

hash_set::const_pointer

Poznámky

hash_set::const_reference

Poznámky

Příklad

hash_set::const_reverse_iterator

Poznámky

Příklad

hash_set::count

Parametry

Návratová hodnota

Poznámky

Příklad

hash_set::crbegin

Návratová hodnota

Poznámky

Příklad

hash_set::crend

Návratová hodnota

Poznámky

Příklad

hash_set::d ifference_type

Poznámky

Příklad

hash_set::emplace

Parametry

Návratová hodnota

Poznámky

Příklad

hash_set::emplace_hint

Parametry

Návratová hodnota

Poznámky

Příklad

hash_set::empty

Návratová hodnota

Poznámky

Příklad

hash_set::end

Návratová hodnota

Poznámky

Příklad

hash_set::equal_range

Parametry

Návratová hodnota

Poznámky

Příklad

hash_set::erase

Parametry