hash_multiset – třída

Článek
07/05/2024

Poznámka:

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

Třída kontejneru hash_multiset je rozšířením standardní knihovny jazyka C++ a používá se pro ukládání a rychlé načítání dat z kolekce, ve které hodnoty prvků obsažené slouží jako hodnoty klíče a nemusí být jedinečné.

Syntaxe

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

Parametry

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

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_multiset a uvolnění paměti. Tento argument je nepovinný a výchozí hodnota je allocator<Key>.

Poznámky

Hash_multiset 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_multiset 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é hashování provádí vložení, odstranění a najde v konstantním průměrném čase ve srovnání s časem úměrným logaritmus 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_multiset by měl být asociativní kontejner podle výběru, pokud aplikace splňuje podmínky asociující hodnoty s jejich klíči. Prvky hash_multiset můžou být více a slouží jako vlastní klíče řazení, takže klíče nejsou jedinečné. Model pro tento typ struktury je uspořádaný seznam slov, v němž se slova mohou vyskytovat více než jednou. Pokud nebylo povoleno více výskytů slov, pak by hash_set byla vhodná struktura kontejneru. Pokud byly jedinečné definice připojeny jako hodnoty k seznamu jedinečných klíčových slov, pak by hash_map byla vhodná struktura, která by tato data obsahovala. Pokud by definice nebyly jedinečné, pak by hash_multimap byl kontejner podle výběru.

Hash_multiset pořadí, které řídí, zavoláním uloženého objektu hash vlastnosti 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<Key, less<Key> >. Konkrétně pro všechny hodnoty Klíč typu , volání Trait(Key) přináší rozdělení hodnot typu size_t.Key

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ý. To má za výsledek řazení mezi neekvivalentními prvky. 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_multiset je striktní slabé řazení, pokud je binární predikát nevýrazný, antisymetrické a tranzitivní a pokud je ekvivalence tranzitivní, kde jsou dva objekty x a y definovány tak, aby byly 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_multiset třídou je obousměrný iterátor, ale členské funkce třídy vkládají a hash_multiset mají verze, které berou jako parametry šablony slabší vstupní iterátor, jehož požadavky na funkčnost jsou minimalnější 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í hash_multiset požadavků a algoritmy, které s nimi pracují, musí omezit své předpoklady na požadavky poskytované tímto typem 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í hash_multiset funkčnosti, ale stačí, abyste mohli smysluplně mluvit o rozsahu iterátorů [ first, last) v kontextu členské funkce třídy.

Konstruktory

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

Typedefs

Název typu	Popis
allocator_type	Typ, který představuje `allocator` třídu objektu `hash_multiset` .
const_iterator	Typ, který poskytuje obousměrný iterátor, který může číst `const` prvek v objektu `hash_multiset`.
const_pointer	Typ, který poskytuje ukazatel na `const` prvek v objektu `hash_multiset`.
const_reference	Typ, který poskytuje odkaz na `const` prvek uložený v objektu `hash_multiset` 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_multiset`.
difference_type	Typ celého čísla se znaky, který poskytuje rozdíl mezi dvěma iterátory, které adresují prvky ve stejném `hash_multiset`.
iterátor	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat libovolný prvek v objektu `hash_multiset`.
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_multiset`.
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_multiset`.
odkaz	Typ, který poskytuje odkaz na prvek uložený v objektu `hash_multiset`.
reverse_iterator	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném směru `hash_multiset`.
size_type	Typ celého čísla bez znaménka, který může představovat počet prvků v objektu `hash_multiset`.
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_multiset` 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_multiset` ve své kapacitě jako hodnotu.

Členské funkce

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

Operátory

Operátor	Popis
hash_multiset::operator=	Nahradí prvky hash_multiset kopií jiného hash_multiset.

Požadavky

Header:<hash_set>

Obor názvů: stdext

hash_multiset::allocator_type

Poznámka:

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

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

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

Příklad

Příklad get_allocator příkladu pomocí allocator_type

hash_multiset::begin

Poznámka:

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

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

const_iterator begin() const;

iterator begin();

Návratová hodnota

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

Poznámky

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

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::const_iterator hms1_cIter;

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

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

   hms1_Iter = hms1.begin( );
   hms1.erase( hms1_Iter );

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

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

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

hash_multiset::cbegin

Poznámka:

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

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

const_iterator cbegin() const;

Návratová hodnota

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

Poznámky

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

Příklad

// hash_multiset_cbegin.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <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_multiset::cend

Poznámka:

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

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

const_iterator cend() const;

Návratová hodnota

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

Poznámky

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

Příklad

// hash_multiset_cend.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <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_multiset::clear

Poznámka:

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

Vymaže všechny prvky hash_multiset.

void clear();

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 1 );
   hms1.insert( 2 );

   cout << "The size of the hash_multiset is initially " << hms1.size( )
        << "." << endl;

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

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

hash_multiset::const_iterator

Poznámka:

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

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

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

Podívejte se na příklad použití const_iterator.

hash_multiset::const_pointer

Poznámka:

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

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

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 měl být const_iterator použit pro přístup k prvkům v objektu const hash_multiset.

hash_multiset::const_reference

Poznámka:

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

Typ, který poskytuje odkaz na const prvek uložený v hash_multiset 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_multiset_const_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 10 );
   hms1.insert( 20 );

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

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

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

The first element in the hash_multiset is 10.

hash_multiset::const_reverse_iterator

Poznámka:

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

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

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_multiset obráceně.

Příklad

Podívejte se na příklad rend příklad, jak deklarovat a používat const_reverse_iterator.

hash_multiset::count

Poznámka:

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

Vrátí počet prvků v hash_multiset, 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_multiset.

Návratová hodnota

Počet prvků v hash_multiset s klíčem zadaným parametrem.

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_multiset::count členské funkce.

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

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multiset<int> hms1;
    hash_multiset<int>::size_type i;

    hms1.insert(1);
    hms1.insert(1);

    // Keys do not need to be unique in hash_multiset,
    // so duplicates may exist.
    i = hms1.count(1);
    cout << "The number of elements in hms1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

hash_multiset::crbegin

Poznámka:

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

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

const_reverse_iterator crbegin() const;

Návratová hodnota

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

Poznámky

crbeginse používá s obráceným kódem stejně jako hash_multiset::begin se používá s parametrem hash_multiset.hash_multiset

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

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

Příklad

// hash_multiset_crbegin.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <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_multiset is "
        << *hs1_crIter << "." << endl;
}

The first element in the reversed hash_multiset is 30.

hash_multiset::crend

Poznámka:

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

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

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_multiset (umístění, které předchází prvnímu prvku v nereverze hash_multiset).

Poznámky

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

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

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

Příklad

// hash_multiset_crend.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hs1;
   hash_multiset <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_multiset is "
        << *hs1_crIter << "." << endl;
}

The last element in the reversed hash_multiset is 10.

hash_multiset::d ifference_type

Poznámka:

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

Typ celého čísla se znaky, který poskytuje rozdíl mezi dvěma iterátory, které adresují prvky ve stejné hash_multiset.

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_multiset_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_set>
#include <algorithm>

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

   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter, hms1_bIter, hms1_eIter;

   hms1.insert( 20 );
   hms1.insert( 10 );

   // hash_multiset elements need not be unique
   hms1.insert( 20 );

   hms1_bIter = hms1.begin( );
   hms1_eIter = hms1.end( );

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

   df_typ5 = count( hms1_bIter, hms1_eIter, 5 );
   df_typ10 = count( hms1_bIter, hms1_eIter, 10 );
   df_typ20 = count( hms1_bIter, hms1_eIter, 20 );

   // The keys & hence the elements of a hash_multiset
   // need not be unique and may occur multiple times
   cout << "The number '5' occurs " << df_typ5
        << " times in hash_multiset hms1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in hash_multiset hms1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in hash_multiset hms1.\n";

   // Count the number of elements in a hash_multiset
   hash_multiset <int>::difference_type  df_count = 0;
   hms1_Iter = hms1.begin( );
   while ( hms1_Iter != hms1_eIter)
   {
      df_count++;
      hms1_Iter++;
   }

   cout << "The number of elements in the hash_multiset hms1 is "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in hash_multiset hms1.
The number '10' occurs 1 times in hash_multiset hms1.
The number '20' occurs 2 times in hash_multiset hms1.
The number of elements in the hash_multiset hms1 is 3.

hash_multiset::emplace

Poznámka:

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

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

template <class ValTy>
iterator insert(ValTy&& val);

Parametry

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

Návratová hodnota

Členová emplace funkce vrátí iterátor, který odkazuje na pozici, kde byl vložen nový prvek.

Poznámky

Příklad

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

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

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

After the emplace insertion, hms3 contains a.

hash_multiset::emplace_hint

Poznámka:

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

Vloží prvek vytvořený na místě do hash_multiset s nápovědou pro umístění.

template <class ValTy>
iterator insert(
    const_iterator where,
    ValTy&& val);

Parametry

Val
Hodnota prvku, který má být vložen do hash_multiset , pokud hash_multiset 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é konstantní době místo logaritmického času, pokud kurzor bezprostředně následuje tam.)

Návratová hodnota

Členová funkce hash_multiset::emplace vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do objektu hash_multiset.

Poznámky

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

Příklad

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

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

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

After the emplace insertion, hms1 contains a.

hash_multiset::empty

Poznámka:

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

Testuje, jestli je hash_multiset prázdný.

bool empty() const;

Návratová hodnota

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

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1, hms2;
   hms1.insert ( 1 );

   if ( hms1.empty( ) )
      cout << "The hash_multiset hms1 is empty." << endl;
   else
      cout << "The hash_multiset hms1 is not empty." << endl;

   if ( hms2.empty( ) )
      cout << "The hash_multiset hms2 is empty." << endl;
   else
      cout << "The hash_multiset hms2 is not empty." << endl;
}

The hash_multiset hms1 is not empty.
The hash_multiset hms2 is empty.

hash_multiset::end

Poznámka:

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

Vrátí iterátor, který řeší umístění úspěšného posledního prvku v hash_multiset.

const_iterator end() const;

iterator end();

Návratová hodnota

Obousměrný iterátor, který adresuje umístění úspěšného posledního prvku v hash_multiset. Pokud je hash_multiset prázdný, hash_multiset::end == hash_multiset::begin.

Poznámky

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

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: iterator hms1_Iter;
   hash_multiset <int> :: const_iterator hms1_cIter;

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

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

   hms1.erase( hms1_Iter );

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

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

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

hash_multiset::equal_range

Poznámka:

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

Vrátí dvojici iterátorů s prvním prvkem v hash_multiset s klíčem, který je větší než zadaný klíč, a k prvnímu prvku v hash_multiset s klíčem, který je roven nebo 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 hash_multiset prohledávaného.

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 dvojice pr 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. druhý a k dereference horního vázaného iterátoru, použijte *( pr. druhý).

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_multiset<int> IntHSet;
   IntHSet hms1;
   hash_multiset <int> :: const_iterator hms1_RcIter;

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

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

   cout << "The upper bound of the element with "
        << "a key of 20\nin the hash_multiset hms1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20\nin the hash_multiset hms1 is: "
        << *(p1.first) << "." << endl;

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

   p2 = hms1.equal_range( 40 );

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

The upper bound of the element with a key of 20
in the hash_multiset hms1 is: 30.
The lower bound of the element with a key of 20
in the hash_multiset hms1 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_multiset hms1 doesn't have an element with a key less than 40.

hash_multiset::erase

Poznámka:

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

Odebere prvek nebo rozsah prvků v hash_multiset 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_multiset.

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

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

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

Návratová hodnota

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

Poznámky

Členské funkce nikdy nevyvolají výjimku.

Příklad

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

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multiset<int> hms1, hms2, hms3;
    hash_multiset<int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_multiset<int>::size_type n;

    for (i = 1; i < 5; i++)
    {
        hms1.insert(i);
        hms2.insert(i * i);
        hms3.insert(i - 1);
    }

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

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

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

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

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

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

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

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

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

After the 2nd element is deleted,
the hash_multiset hms1 is: 1 3 4.
After the middle two elements are deleted,
the hash_multiset hms2 is: 16 4.
After the element with a key of 2 is deleted,
the hash_multiset hms3 is: 0 1 3.
The number of elements removed from hms3 is: 1.
After another element with a key equal to that of the 2nd element
is deleted, the hash_multiset hms3 is: 0 3.

hash_multiset::find

Poznámka:

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

Vrátí iterátor adresovaný umístění prvku v hash_multiset, 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_multiset.

Návratová hodnota

Iterátor nebo const_iterator, který řeší umístění elementu ekvivalentního zadanému klíči nebo které adresuje umístění úspěšného posledního prvku v hash_multiset, pokud se pro klíč nenajde žádná shoda.

Poznámky

Členská funkce vrátí iterátor, který řeší prvek v hash_multiset jehož klíč řazení je equivalent na 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 hash_multiset objekt změnit. Pokud je vrácená hodnota find přiřazena k objektu iterator, lze upravit hash_multiset objekt.

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

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

   hms1_RcIter = hms1.find( 20 );
   cout << "The element of hash_multiset hms1 with a key of 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.find( 40 );

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

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

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

hash_multiset::get_allocator

Poznámka:

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

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

Allocator get_allocator() const;

Návratová hodnota

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

Další informace naleznete Allocatorv části Poznámky v tématu hash_multiset Třída .

Poznámky

Alokátory pro třídu hash_multiset 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_multiset_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_multiset <int, hash_compare <int, less<int> > > hms1;
   hash_multiset <int, hash_compare <int, greater<int> > > hms2;
   hash_multiset <double, hash_compare <double,
      less<double> >, allocator<double> > hms3;

   hash_multiset <int, hash_compare <int,
      greater<int> > >::allocator_type hms2_Alloc;
   hash_multiset <double>::allocator_type hms3_Alloc;
   hms2_Alloc = hms2.get_allocator( );

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

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

   // The following lines create a hash_multiset hms4
   // with the allocator of hash_multiset hms1.
   hash_multiset <int>::allocator_type hms4_Alloc;
   hash_multiset <int> hms4;
   hms4_Alloc = hms2.get_allocator( );

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

hash_multiset::hash_multiset

Poznámka:

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

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

hash_multiset();

explicit hash_multiset(
    const Traits& Comp);

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

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

hash_multiset(
    hash_multiset&& Right
};
hash_multiset (initializer_list<Type> IList);

hash_multiset(
    initializer_list<Tu[e> IList, const Compare& Comp):
hash_multiset(
    initializer_list<Type> IList, const Compare& Comp, const Allocator& Al);

template <class InputIterator>
hash_multiset(
    InputIterator first,
    InputIterator last);

template <class InputIterator>
hash_multiset(
    InputIterator first,
    InputIterator last,
    const Traits& Comp);

template <class InputIterator>
hash_multiset(
    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_multiset objekt, což je výchozí hodnota Allocator.

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

Right
Z hash_multiset nichž vytvořený hash_multiset 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.

IList
Initializer_list obsahující prvky, 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_multiset a který lze později vrátit voláním hash_multiset::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í své hash_multisets.

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

První tři konstruktory určují prázdný počáteční hash_multiset, druhý určující typ porovnávací funkce (Comp), která se má použít při stanovení pořadí prvků a třetí explicitně určující typ alokátoru (Al), který se má použít. Klíčové slovo explicit potlačí určité druhy automatického převodu typů.

Čtvrtý konstruktor přesune hash_multiset Right.

Pátý, šestý a sedmý konstruktor používají initializer_list.

Poslední tři konstruktory zkopírují rozsah [ first, last) hash_multiset s rostoucí explicitností při určení typu porovnávací funkce třídy Compare a alokátoru.

Skutečné pořadí prvků v kontejneru hodnot hashované sady 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_multiset::insert

Poznámka:

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

Vloží prvek nebo oblast prvků do hash_multiset.

iterator insert(
    const Type& value);

iterator insert(
    iterator where,
    const Type& Al);

void insert(
    initializer_list<Type> IList);

iterator insert(
    const Type& value);

iterator insert(
    Iterator where,
    const Type& value);

template <class InputIterator>
void insert(
    InputIterator first,
    InputIterator last);

template <class ValTy>
iterator insert(
    ValTy&& value);

template <class ValTy>
iterator insert(
    const_iterator where,
    ValTy&& value);

Parametry

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

první
Pozice prvního prvku, který se má zkopírovat z hash_multiset.

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

IList
Initializer_list obsahující prvky, které se mají zkopírovat.

Návratová hodnota

První dvě členské funkce vložení vrátí iterátor, který odkazuje na pozici, kde byl vložen nový prvek.

Další tři členské funkce používají initializer_list.

Třetí člen funkce vloží posloupnost hodnot prvků do hash_multiset odpovídající každému prvku adresovaném iterátorem v rozsahu [ , firstlast) zadaného hash_multiset.

Poznámky

Vložení může nastat v amortizované konstantní době pro verzi nápovědy vložení místo logaritmického času, pokud kurzor bezprostředně následuje tam, kde.

hash_multiset::iterator

Poznámka:

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

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

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, jak deklarovat a používat iterator.

hash_multiset::key_comp

Poznámka:

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

Načte kopii objektu porovnání použitého k řazení klíčů v hash_multiset.

key_compare key_comp() const;

Návratová hodnota

Vrátí hash_multiset parametru šablony Traits, který obsahuje objekty funkce, které se používají k hash a pořadí prvků kontejneru.

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

Poznámky

Uložený objekt definuje členovou 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_multiset a hash_multiset, kde jsou identické, kvůli kompatibilitě s hash_map a třídami hash_multimap, kde jsou odlišné.

Příklad

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

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

   hash_multiset <int, hash_compare < int, less<int> > >hms1;
   hash_multiset<int, hash_compare < int, less<int> > >::key_compare kc1
          = hms1.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 hms1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of hms1."
        << endl;
   }

   hash_multiset <int, hash_compare < int, greater<int> > > hms2;
   hash_multiset<int, hash_compare < int, greater<int> > >::key_compare
         kc2 = hms2.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 hms2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of hms2."
           << endl;
   }
}

hash_multiset::key_compare

Poznámka:

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

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

typedef Traits key_compare;

Poznámky

key_compare je synonymem parametru šablony Traits.

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

Všimněte si, že key_compare oba a 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

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

hash_multiset::key_type

Poznámka:

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

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

typedef Key key_type;

Poznámky

key_typeje synonymem pro klíč parametru šablony.

Všimněte si, že key_type value_type jsou synonyma pro klíč 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é.

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

Příklad

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

hash_multiset::lower_bound

Poznámka:

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

Vrátí iterátor na první prvek v hash_multiset 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 hash_multiset prohledávaného.

Návratová hodnota

Iterátor nebo const_iterator, který řeší umístění prvního prvku v hash_multiset s klíčem, který je roven nebo větší než klíč argumentu, nebo adresuje umístění úspěšného posledního prvku v hash_multiset, pokud se pro klíč nenajde žádná shoda.

Poznámky

Příklad

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

int main() {
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

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

   hms1_RcIter = hms1.lower_bound( 20 );
   cout << "The element of hash_multiset hms1 with a key of 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.lower_bound( 40 );

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

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

hash_multiset::max_size

Poznámka:

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

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

size_type max_size() const;

Návratová hodnota

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

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::size_type i;

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

hash_multiset::operator=

Poznámka:

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

Nahradí prvky hash_multiset kopií jiného hash_multiset.

hash_multiset& operator=(const hash_multiset& right);

hash_multiset& operator=(hash_multiset&& right);

Parametry

Vpravo
Hash_multiset, která se kopíruje do souboru hash_multiset.

Poznámky

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

Příklad

// hash_multiset_operator_as.cpp
// compile with: /EHsc
#include <hash_multiset>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset<int> v1, v2, v3;
   hash_multiset<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_multiset::p ointer

Poznámka:

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

Typ, který poskytuje ukazatel na prvek v hash_multiset.

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 s více sadami.

hash_multiset::rbegin

Poznámka:

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

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

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_multiset nebo adresování toho, co bylo posledním prvkem v nereverzním hash_multiset.

Poznámky

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

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

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

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::reverse_iterator hms1_rIter;

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

   hms1_rIter = hms1.rbegin( );
   cout << "The first element in the reversed hash_multiset is "
        << *hms1_rIter << "." << endl;

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

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

   // A hash_multiset element can be erased by dereferencing to its key
   hms1_rIter = hms1.rbegin( );
   hms1.erase ( *hms1_rIter );

   hms1_rIter = hms1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_multiset is "<< *hms1_rIter << "."
        << endl;
}

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

hash_multiset::reference

Poznámka:

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

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

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

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;

   hms1.insert( 10 );
   hms1.insert( 20 );

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

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

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

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

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

hash_multiset::rend

Poznámka:

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

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

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_multiset (umístění, které předchází prvnímu prvku v nereverzním hash_multiset).

Poznámky

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

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iterator, nelze hash_multiset objekt změnit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iterator, lze upravit hash_multiset 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_multiset.

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;
   hash_multiset <int>::reverse_iterator hms1_rIter;
   hash_multiset <int>::const_reverse_iterator hms1_crIter;

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

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   cout << "The last element in the reversed hash_multiset is "
        << *hms1_rIter << "." << endl;

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

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

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   hms1.erase ( *hms1_rIter );

   hms1_rIter = hms1.rend( );
   hms1_rIter--;
   cout << "After the erasure, the last element in the "
        << "reversed hash_multiset is " << *hms1_rIter << "."
        << endl;
}

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

hash_multiset::reverse_iterator

Poznámka:

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

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

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_multiset obráceně.

Příklad

Příklad deklarování a použití reverse_iteratornajdete v příkladu rbegin .

hash_multiset::size

Poznámka:

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

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

size_type size() const;

Návratová hodnota

Aktuální délka hash_multiset.

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: size_type i;

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

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

The hash_multiset length is 1.
The hash_multiset length is now 2.

hash_multiset::size_type

Poznámka:

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

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

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

Poznámky

Příklad

Příklad, jak deklarovat a používat velikost, najdete v příkladu velikosti . size_type

hash_multiset::swap

Poznámka:

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

Vymění prvky dvou hash_multisets.

void swap(hash_multiset& right);

Parametry

Vpravo
Argument hash_multiset poskytnutí prvků, které mají být prohozeny s cílovým hash_multiset.

Poznámky

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

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1, hms2, hms3;
   hash_multiset <int>::iterator hms1_Iter;

   hms1.insert( 10 );
   hms1.insert( 20 );
   hms1.insert( 30 );
   hms2.insert( 100 );
   hms2.insert( 200 );
   hms3.insert( 300 );

   cout << "The original hash_multiset hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   hms1.swap( hms2 );

   cout << "After swapping with hms2, list hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hms1, hms3 );

   cout << "After swapping with hms3, list hms1 is:";
   for ( hms1_Iter = hms1.begin( ); hms1_Iter != hms1.end( );
         hms1_Iter++ )
         cout << " " << *hms1_Iter;
   cout   << "." << endl;
}

The original hash_multiset hms1 is: 10 20 30.
After swapping with hms2, list hms1 is: 200 100.
After swapping with hms3, list hms1 is: 300.

hash_multiset::upper_bound

Poznámka:

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

Vrátí iterátor na první prvek v hash_multiset 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 hash_multiset prohledávaného.

Návratová hodnota

Iterátor nebo const_iterator, který řeší umístění prvního prvku v hash_multiset s klíčem větším než klíč argumentu, nebo který řeší umístění úspěšného posledního prvku v hash_multiset pokud se pro klíč nenajde žádná shoda.

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int> :: const_iterator hms1_AcIter, hms1_RcIter;

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

   hms1_RcIter = hms1.upper_bound( 20 );
   cout << "The first element of hash_multiset hms1" << endl
        << "with a key greater than 20 is: "
        << *hms1_RcIter << "." << endl;

   hms1_RcIter = hms1.upper_bound( 30 );

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

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

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

hash_multiset::value_comp

Poznámka:

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

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

value_compare value_comp() const;

Návratová hodnota

Vrátí hash_multiset parametru šablony Traits, který obsahuje objekty funkce, které se používají k hash a pořadí prvků kontejneru.

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

Poznámky

Uložený objekt definuje členovou funkci:

bool – operátor( constKey&_xVal; const Key&_yVal);

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

Příklad

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

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

   hash_multiset <int, hash_compare < int, less<int> > > hms1;
   hash_multiset <int, hash_compare < int, less<int> > >::value_compare
      vc1 = hms1.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 hms1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of hms1."
           << endl;
   }

   hash_multiset <int, hash_compare < int, greater<int> > > hms2;
   hash_multiset<int, hash_compare < int, greater<int> > >::
           value_compare vc2 = hms2.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 hms2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of hms2."
           << endl;
   }
}

vc1( 2,3 ) returns value of true, where vc1 is the function object of hms1.
vc2( 2,3 ) returns value of false, where vc2 is the function object of hms2.

hash_multiset::value_compare

Poznámka:

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

typedef key_compare value_compare;

Poznámky

value_compare je synonymem parametru šablony Traits.

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

Všimněte si, že key_compare i value_compare synonyma pro vlastnosti parametru šablony. Oba typy jsou k dispozici pro sady tříd a více sad, kde jsou identické, z důvodu kompatibility s mapou tříd a multimap, kde jsou odlišné.

Příklad

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

hash_multiset::value_type

Poznámka:

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

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

typedef Key value_type;

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multiset <int> hms1;
   hash_multiset <int>::iterator hms1_Iter;

   // Declare value_type
   hash_multiset <int> :: value_type hmsvt_Int;

   hmsvt_Int = 10;   // Initialize value_type

   // Declare key_type
   hash_multiset <int> :: key_type hmskt_Int;
   hmskt_Int = 20;             // Initialize key_type

   hms1.insert( hmsvt_Int );         // Insert value into s1
   hms1.insert( hmskt_Int );         // Insert key into s1

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

The hash_multiset 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_multiset – třída

Syntaxe

Parametry

Poznámky

Konstruktory

Typedefs

Členské funkce

Operátory

Požadavky

hash_multiset::allocator_type

Příklad

hash_multiset::begin

Návratová hodnota

Poznámky

Příklad

hash_multiset::cbegin

Návratová hodnota

Poznámky

Příklad

hash_multiset::cend

Návratová hodnota

Poznámky

Příklad

hash_multiset::clear

Poznámky

Příklad

hash_multiset::const_iterator

Poznámky

Příklad

hash_multiset::const_pointer

Poznámky

hash_multiset::const_reference

Poznámky

Příklad

hash_multiset::const_reverse_iterator

Poznámky

Příklad

hash_multiset::count

Parametry

Návratová hodnota

Poznámky

Příklad

hash_multiset::crbegin

Návratová hodnota

Poznámky

Příklad

hash_multiset::crend

Návratová hodnota

Poznámky

Příklad

hash_multiset::d ifference_type

Poznámky

Příklad

hash_multiset::emplace

Parametry

Návratová hodnota

Poznámky

Příklad

hash_multiset::emplace_hint

Parametry

Návratová hodnota

Poznámky

Příklad

hash_multiset::empty

Návratová hodnota

Poznámky

Příklad

hash_multiset::end

Návratová hodnota

Poznámky

Příklad

hash_multiset::equal_range

Parametry

Návratová hodnota

Příklad

hash_multiset::erase

Parametry

Návratová hodnota

Poznámky