hash_multimap – třída

Článek
07/05/2024

Poznámka:

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

Třída kontejneru hash_multimap je rozšíření standardní knihovny jazyka C++ a slouží k ukládání a rychlému načítání dat z kolekce, ve které je každý prvek párem, který má klíč řazení, jehož hodnota nemusí být jedinečná a přidružená datová hodnota.

Syntaxe

template <class Key,
    class Type,
    class Traits=hash_compare <Key, less <Key>>,
    class Allocator=allocator <pair  <const Key, Type>>>
class hash_multimap

Parametry

Klíč
Datový typ klíče, který se má uložit v hash_multimap.

Typ
Datový typ elementu, který má být uložen v hash_multimap.

Rysy
Typ, který obsahuje dva objekty funkce, jeden z vlastností třídy, který je 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ý alokátor objekt, který zapouzdřuje podrobnosti o přidělení hash_multimap a uvolnění paměti. Tento argument je nepovinný a výchozí hodnota je allocator<pair <const Key, Type>>.

Poznámky

Hash_multimap 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.
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ů.
Vícenásobný, protože je prvky nemusí mít jedinečné klíče, takže jedna hodnota klíče může mít k sobě přidružených mnoho datových hodnot prvků.
Asociativní kontejner páru, protože jeho hodnoty prvků se liší od hodnot klíče.
Š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í. Hodnota prvku v hash_multimap, ale ne její přidružená hodnota klíče, může být změněna přímo. Namísto toho hodnoty klíčů přidružené ke starým prvkům musí být odstraněny a vloženy nové hodnoty klíče související s novými prvky.

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_multimap by měla být asociativním kontejnerem podle výběru, pokud aplikace splňuje podmínky přidružení hodnot k jejich klíčům. Model pro tento typ struktury je uspořádaný seznam klíčových slov s přidruženými řetězcovými hodnotami poskytujícími (řekněme) definice, kde slova nebyla vždy jednoznačně definována. Pokud by se místo toho klíčová slova jedinečně definovala tak, aby klíče byly jedinečné, pak hash_map by byl kontejner, který je volbou. Pokud by se naopak ukládaly jenom seznam slov, pak by hash_set byl správný kontejner. Pokud bylo povoleno více výskytů slov, pak by hash_multiset byla vhodná struktura kontejneru.

Hash_multimap 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<Key, less<Key>>. Konkrétně pro všechny hodnoty Key typu , volání Traits (Key) přináší rozdělení hodnot typu size_tKey.

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 návratovou hodnotu true nebo false. Pořadí uložené na hash_multimap je striktní slabé řazení, pokud je binární predikát neflexivní, antisymetrické a tranzitivní a pokud je ekvivalence tranzitivní, kde jsou dva objekty a y jsou definovány x jako ekvivalentní, pokud jsou f(x, y) a f(y, x) false. 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_multimap třídou je obousměrný iterátor, ale členské funkce třídy vkládají a hash_multimap mají verze, které berou jako parametry šablony slabší vstupní iterátor, jehož požadavky na funkčnost jsou 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í hash_multimap 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_multimap funkčnosti, ale stačí, abyste mohli smysluplně mluvit o rozsahu iterátorů [First, Last) v kontextu členských funkcí.

Konstruktory

Konstruktor	Popis
hash_multimap	Vytvoří seznam určité velikosti nebo s prvky určité hodnoty nebo s určitými `allocator` nebo jako kopie některých jiných `hash_multimap`.

Typedefs

Název typu	Popis
allocator_type	Typ, který představuje `allocator` třídu objektu `hash_multimap` .
const_iterator	Typ, který poskytuje obousměrný iterátor, který může číst `const` prvek v objektu `hash_multimap`.
const_pointer	Typ, který poskytuje ukazatel na `const` prvek v objektu `hash_multimap`.
const_reference	Typ, který poskytuje odkaz na `const` prvek uložený v objektu `hash_multimap` 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_multimap`.
difference_type	Typ celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků `hash_multimap` 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_multimap`.
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_multimap`.
key_type	Typ, který popisuje objekt klíče řazení, který představuje každý prvek objektu `hash_multimap`.
mapped_type	Typ, který představuje datový typ uložený v objektu `hash_multimap`.
ukazatel	Typ, který poskytuje ukazatel na prvek v objektu `hash_multimap`.
odkaz	Typ, který poskytuje odkaz na prvek uložený v objektu `hash_multimap`.
reverse_iterator	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném směru `hash_multimap`.
size_type	Typ celého čísla bez znaménka, který může představovat počet prvků v objektu `hash_multimap`.
value_type	Typ, který poskytuje objekt funkce, který může porovnat dva prvky jako klíče řazení k určení jejich relativního pořadí v objektu `hash_multimap`.

Členské funkce

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

Operátory

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

Požadavky

Záhlaví:<hash_map>

Obor názvů: stdext

hash_multimap::allocator_type

Poznámka:

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

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

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

Poznámky

allocator_type je synonymem parametru Allocatoršablony .

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

Příklad

Podívejte se na příklad get_allocator příkladu pomocí allocator_type.

hash_multimap::begin

Poznámka:

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

Vrátí iterátor adresování prvního prvku v hash_multimap.

const_iterator begin() const;

iterator begin();

Návratová hodnota

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

Poznámky

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

Příklad

// hash_multimap_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 0, 0 ) );
   hm1.insert ( Int_Pair ( 1, 1 ) );
   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.begin ( );
   cout << "The first element of hm1 is " << hm1_cIter -> first
        << "." << endl;

   hm1_Iter = hm1.begin ( );
   hm1.erase ( hm1_Iter );

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

   hm1_cIter = hm1.begin( );
   cout << "The first element of hm1 is now " << hm1_cIter -> first
        << "." << endl;
}

The first element of hm1 is 0.
The first element of hm1 is now 1.

hash_multimap::cbegin

Poznámka:

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

Vrátí konstantní iterátor adresování prvního prvku v hash_multimap.

const_iterator cbegin() const;

Návratová hodnota

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

Příklad

// hash_multimap_cbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.cbegin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;
   }

The first element of hm1 is 2.

hash_multimap::cend

Poznámka:

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

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

const_iterator cend() const;

Návratová hodnota

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

Poznámky

cend slouží k otestování, zda iterátor dosáhl konce hash_multimap.

Hodnota vrácená cend hodnotou by neměla být dereferenced.

Příklad

// hash_multimap_cend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.cend( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;
   }

The value of last element of hm1 is 30.

hash_multimap::clear

Poznámka:

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

Vymaže všechny prvky hash_multimap.

void clear();

Poznámky

Příklad

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

// hash_multimap_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    hm1.insert(Int_Pair(2, 4));

    i = hm1.size();
    cout << "The size of the hash_multimap is initially "
         << i  << "." << endl;

    hm1.clear();
    i = hm1.size();
    cout << "The size of the hash_multimap after clearing is "
         << i << "." << endl;
}

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

hash_multimap::const_iterator

Poznámka:

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

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

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.

Definice const_iterator hash_multimap odkazuje na objekty value_type, které jsou typu pair<const Key, Type>. Hodnota klíče je k dispozici prostřednictvím prvního páru členů a hodnota mapovaného prvku je k dispozici prostřednictvím druhého člena dvojice.

Pokud chcete odkazovat const_iterator cIter na prvek v hash_multimap, použijte -> operátor.

Chcete-li získat přístup k hodnotě klíče pro prvek, použijte cIter->first, což je ekvivalentní (*cIter).first. Pro přístup k hodnotě mapovaného data pro prvek použijte cIter->second, což je ekvivalentní (*cIter).second.

Příklad

Podívejte se na příklad pro začátek příkladu pomocí const_iterator.

hash_multimap::const_pointer

Poznámka:

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

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

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 iterátor použit pro přístup k prvkům v objektu hash_multimap.

hash_multimap::const_reference

Poznámka:

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

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of first element in the hash_multimap is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin() -> second );

   cout << "The data value of 1st element in the hash_multimap is "
        << Ref2 << "." << endl;
}

The key of first element in the hash_multimap is 1.
The data value of 1st element in the hash_multimap is 10.

hash_multimap::const_reverse_iterator

Poznámka:

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

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

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

Definovaný const_reverse_iterator hash_multimap odkazuje na objekty value_type, které jsou typu pair<const Key, Type>, jehož prvním členem je klíč k prvku a jehož druhý člen je mapovaný datum uchovávané prvkem.

Pokud chcete odkazovat const_reverse_iterator crIter na prvek v hash_multimap, použijte -> operátor.

Chcete-li získat přístup k hodnotě klíče pro prvek, použijte crIter->first, což je ekvivalentní (*crIter).first. Pro přístup k hodnotě mapovaného data pro prvek použijte crIter->second, což je ekvivalentní (*crIter).second.

Příklad

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

hash_multimap::count

Poznámka:

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

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

Návratová hodnota

1, pokud hash_multimap obsahuje prvek, jehož klíč řazení odpovídá klíči parametru; 0, pokud hash_multimap neobsahuje prvek s odpovídajícím klíčem.

Poznámky

Členová funkce vrátí počet prvků v oblasti.

[lower_bound ( key ), upper_bound ( ) key

které mají klíč hodnoty klíče.

Příklad

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

// hash_multimap_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    hm1.insert(Int_Pair(2, 1));
    hm1.insert(Int_Pair(1, 4));
    hm1.insert(Int_Pair(2, 1));

    // Elements do not need to have unique keys in hash_multimap,
    // so duplicates are allowed and counted
    i = hm1.count(1);
    cout << "The number of elements in hm1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

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

hash_multimap::crbegin

Poznámka:

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

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

const_reverse_iterator crbegin() const;

Návratová hodnota

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

Poznámky

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

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

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

Příklad

// hash_multimap_crbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crbegin( );
   cout << "The first element of the reversed hash_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_multimap hm1 is 3.

hash_multimap::crend

Poznámka:

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

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

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

Poznámky

crend se používá s obráceným hash_multimap stejně jako hash_multimap::end se používá s hash_multimap.

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

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

Hodnota vrácená crend hodnotou by neměla být dereferenced.

Příklad

// hash_multimap_crend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crend( );
   hm1_crIter--;
   cout << "The last element of the reversed hash_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_multimap hm1 is 3.

hash_multimap::d ifference_type

Poznámka:

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

Typ celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků hash_multimap 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 [ první, poslední) mezi iterátory first a last, zahrnuje prvek, na který first odkazuje, a rozsah prvků až do, ale nikoli včetně prvku, na který odkazuje last.

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.

Příklad

// hash_multimap_difference_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(2, 20));
    hm1.insert(Int_Pair(1, 10));
    hm1.insert(Int_Pair(3, 20));

    // The following will insert, because map keys
    // do not need to be unique
    hm1.insert(Int_Pair(2, 30));

    hash_multimap<int, int>::iterator hm1_Iter, hm1_bIter, hm1_eIter;
    hm1_bIter = hm1.begin();
    hm1_eIter = hm1.end();

    // Count the number of elements in a hash_multimap
    hash_multimap<int, int>::difference_type df_count = 0;
    hm1_Iter = hm1.begin();
    while (hm1_Iter != hm1_eIter)
    {
        df_count++;
        hm1_Iter++;
    }

    cout << "The number of elements in the hash_multimap hm1 is: "
         << df_count << "." << endl;

    cout << "The keys of the mapped elements are:";
    for (hm1_Iter= hm1.begin() ; hm1_Iter!= hm1.end();
        hm1_Iter++)
        cout << " " << hm1_Iter-> first;
    cout << "." << endl;

    cout << "The values of the mapped elements are:";
    for (hm1_Iter= hm1.begin() ; hm1_Iter!= hm1.end();
        hm1_Iter++)
        cout << " " << hm1_Iter-> second;
    cout << "." << endl;
}

The number of elements in the hash_multimap hm1 is: 4.
The keys of the mapped elements are: 1 2 2 3.
The values of the mapped elements are: 10 20 30 20.

hash_multimap::emplace

Poznámka:

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

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

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

Parametry

Val
Hodnota použitá k přesunutí konstruktoru, který se má vložit do hash_multimap.

Návratová hodnota

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

Poznámky

Hash_multimap ::value_type prvku je dvojice, takže hodnota prvku bude seřazený pár s první komponentou, která se rovná hodnotě klíče a druhá komponenta rovna datové hodnotě prvku.

Příklad

// hash_multimap_emplace.cpp
// compile with: /EHsc
#include<hash_multimap>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(move(is1));
    cout << "After the emplace, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_multimap::emplace_hint

Poznámka:

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

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

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

Parametry

Val
Hodnota použitá k přesunutí konstruktoru, který má být vložen do hash_multimap , pokud hash_multimap již tento prvek neobsahuje (nebo obecně prvek, jehož klíč je odpovídajícím způsobem seřazen).

_Kde
Nápověda týkající se místa, kde můžete začít hledat správný bod vložení.

Návratová hodnota

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

Poznámky

Hash_multimap ::value_type prvku je dvojice, takže hodnota prvku bude seřazený pár s první komponentou, která se rovná hodnotě klíče a druhá komponenta rovna datové hodnotě prvku.

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_multimap_emplace_hint.cpp
// compile with: /EHsc
#include<hash_multimap>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(hm1.begin(), move(is1));
    cout << "After the emplace insertion, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_multimap::empty

Poznámka:

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

Testuje, jestli je hash_multimap prázdný.

bool empty() const;

Návratová hodnota

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

Poznámky

Příklad

// hash_multimap_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1, hm2;

   typedef pair <int, int> Int_Pair;
   hm1.insert ( Int_Pair ( 1, 1 ) );

   if ( hm1.empty( ) )
      cout << "The hash_multimap hm1 is empty." << endl;
   else
      cout << "The hash_multimap hm1 is not empty." << endl;

   if ( hm2.empty( ) )
      cout << "The hash_multimap hm2 is empty." << endl;
   else
      cout << "The hash_multimap hm2 is not empty." << endl;
}

The hash_multimap hm1 is not empty.
The hash_multimap hm2 is empty.

hash_multimap::end

Poznámka:

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

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

const_iterator end() const;

iterator end();

Návratová hodnota

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

Poznámky

end slouží k otestování, zda iterátor dosáhl konce hash_multimap.

Hodnota vrácená end hodnotou by neměla být dereferenced.

Příklad

// hash_multimap_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;

   hm1_Iter = hm1.end( );
   hm1_Iter--;
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.end ( );
   // hm1_cIter--;
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is now "
        << hm1_cIter -> second << "." << endl;
}

The value of last element of hm1 is 30.
The value of last element of hm1 is now 20.

hash_multimap::equal_range

Poznámka:

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

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

Návratová hodnota

Dvojice iterátorů tak, aby 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ý).

Poznámky

Příklad

// hash_multimap_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_multimap <int, int> IntMMap;
   IntMMap hm1;
   hash_multimap <int, int> :: const_iterator hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   pair <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

   cout << "The lower bound of the element with a key of 2\n"
        << "in the hash_multimap hm1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with a key of 2\n"
        << "in the hash_multimap hm1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   hm1_RcIter = hm1.upper_bound( 2 );

   cout << "A direct call of upper_bound( 2 ) gives "
        << hm1_RcIter -> second << "," << endl
        << "matching the 2nd element of the pair "
        << "returned by equal_range( 2 )." << endl;

   p2 = hm1.equal_range( 4 );

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

The lower bound of the element with a key of 2
in the hash_multimap hm1 is: 20.
The upper bound of the element with a key of 2
in the hash_multimap hm1 is: 30.
A direct call of upper_bound( 2 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 2 ).
The hash_multimap hm1 doesn't have an element with a key less than 4.

hash_multimap::erase

Poznámka:

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

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

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

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

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

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_multimap pokud žádný takový prvek neexistuje.

U třetí členské funkce vrátí počet prvků, které byly z hash_multimap odebrány.

Poznámky

Členské funkce nikdy nevyvolají výjimku.

Příklad

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

// hash_multimap_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1, hm2, hm3;
    hash_multimap<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_multimap<int, int>::size_type n;
    typedef pair<int, int> Int_Pair;

    for (i = 1; i < 5; i++)
    {
        hm1.insert(Int_Pair (i, i) );
        hm2.insert(Int_Pair (i, i*i) );
        hm3.insert(Int_Pair (i, i-1) );
    }

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

    cout << "After the 2nd element is deleted, "
         << "the hash_multimap hm1 is:";
    for (pIter = hm1.begin(); pIter != hm1.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

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

    cout << "After the middle two elements are deleted, "
         << "the hash_multimap hm2 is:";
    for (pIter = hm2.begin(); pIter != hm2.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    hm3.insert(Int_Pair (2, 5));
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_multimap hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

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

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

    cout << "After another element with a key equal to that of the"
         << endl;
    cout  << "2nd element is deleted, "
          << "the hash_multimap hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_multimap hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_multimap hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_multimap hm3 is: 0 2 3.
The number of elements removed from hm3 is: 2.
After another element with a key equal to that of the
2nd element is deleted, the hash_multimap hm3 is: 0 3.

hash_multimap::find

Poznámka:

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

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

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

Návratová hodnota

Iterátor, který řeší první umístění prvku se zadaným klíčem, nebo umístění úspěšné poslední prvek v hash_multimap, pokud se pro klíč nenajde žádná shoda.

Poznámky

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

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

Příklad

// hash_multimap_find.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 10));
    hm1.insert(Int_Pair(2, 20));
    hm1.insert(Int_Pair(3, 20));
    hm1.insert(Int_Pair(3, 30));

    hm1_RcIter = hm1.find(2);
    cout << "The element of hash_multimap hm1 with a key of 2 is: "
          << hm1_RcIter -> second << "." << endl;

    hm1_RcIter = hm1.find(3);
    cout << "The first element of hash_multimap hm1 with a key of 3 is: "
          << hm1_RcIter -> second << "." << endl;

    // If no match is found for the key, end() is returned
    hm1_RcIter = hm1.find(4);

    if (hm1_RcIter == hm1.end())
        cout << "The hash_multimap hm1 doesn't have an element "
             << "with a key of 4." << endl;
    else
        cout << "The element of hash_multimap hm1 with a key of 4 is: "
             << hm1_RcIter -> second << "." << endl;

    // The element at a specific location in the hash_multimap can be
    // found using a dereferenced iterator addressing the location
    hm1_AcIter = hm1.end();
    hm1_AcIter--;
    hm1_RcIter = hm1.find(hm1_AcIter -> first);
    cout << "The first element of hm1 with a key matching"
         << endl << "that of the last element is: "
         << hm1_RcIter -> second << "." << endl;

    // Note that the first element with a key equal to
    // the key of the last element is not the last element
    if (hm1_RcIter == --hm1.end())
        cout << "This is the last element of hash_multimap hm1."
             << endl;
    else
        cout << "This is not the last element of hash_multimap hm1."
             << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::get_allocator

Poznámka:

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

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

Allocator get_allocator() const;

Návratová hodnota

Alokátor používaný hash_multimap.

Poznámky

Alokátory pro hash_multimap třídu 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_multimap_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int>::allocator_type hm1_Alloc;
   hash_multimap <int, int>::allocator_type hm2_Alloc;
   hash_multimap <int, double>::allocator_type hm3_Alloc;
   hash_multimap <int, int>::allocator_type hm4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> hm2;
   hash_multimap <int, double> hm3;

   hm1_Alloc = hm1.get_allocator( );
   hm2_Alloc = hm2.get_allocator( );
   hm3_Alloc = hm3.get_allocator( );

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

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

   // The following line creates a hash_multimap hm4
   // with the allocator of hash_multimap hm1.
   hash_multimap <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

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

hash_multimap::hash_multimap

Poznámka:

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

Vytvoří hash_multimap, která je prázdná nebo je kopií všech nebo částí jiných hash_multimap.

hash_multimap();

explicit hash_multimap(
    const Compare& Comp);

hash_multimap(
    const Compare& Comp,
    const Allocator& Al);

hash_multimap(
    const hash_multimap& Right);

hash_multimap(
    hash_multimap&& Right);

hash_multimap(
    initializer_list<Type> IList);

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

hash_multimap(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

template <class InputIterator>
hash_multimap(
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

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

Parametry

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

Comp
Funkce porovnání typu const Traits použitá k seřazení prvků v mapě, která je ve výchozím nastavení Traits.

Right
Objekt map, ze kterého je kopií vytvořen objekt set.

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, ze které chcete kopírovat.

Poznámky

Všechny konstruktory ukládají typ objektu alokátoru, který spravuje úložiště paměti pro hash_multimap a které lze později vrátit voláním get_allocator. Parametr alokátoru je často vynechán v deklarací tříd a předzpracování maker se používají k nahrazení alternativních alokátorů.

Všechny konstruktory inicializují jejich hash_multimap.

Všechny konstruktory ukládají objekt funkce typu Traits , který se používá k vytvoření pořadí mezi klíči hash_multimap a lze je později vrátit voláním key_comp.

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

Čtvrtý konstruktor určuje kopii hash_multimap Right.

Další tři konstruktory zkopírují rozsah First, Last) mapy s rostoucí explicitností při určení typu porovnávací funkce třídy Traits a alokátoru.

Osmý konstruktor přesune hash_multimap Right.

Poslední tři konstruktory používají initializer_list.

hash_multimap::insert

Poznámka:

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

Vloží prvek nebo oblast prvků do hash_multimap.

iterator insert(
    const value_type& Val);

iterator insert(
    const_iterator Where,
    const value_type& Val);void insert(
    initializer_list<value_type> IList);

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

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

template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

Parametry

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

Kde
Nápověda, kde začít hledat správný bod vložení.

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

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

Návratová hodnota

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

Třetí členová funkce používá initializer_list k vložení prvků.

Čtvrtá členová funkce vloží sekvenci hodnot prvků do mapy, která odpovídá jednotlivým prvkům adresovaným iterátorem v rozsahu [First, Last) zadané sady.

Poslední dvě insert členské funkce se chovají stejně jako první dvě, s tím rozdílem, že přesunou vloženou hodnotu.

Poznámky

Value_type prvku je dvojice, takže hodnota prvku bude seřazený pár, ve kterém se první komponenta rovná hodnotě klíče a druhá komponenta se rovná datové hodnotě prvku.

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

hash_multimap::iterator

Poznámka:

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

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

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

Poznámky

Definice iterator hash_multimap odkazuje na objekty value_type, které jsou typu pair<const Key, Type>, jehož první člen je klíčem k prvku a jehož druhý člen je mapovaný datum uchovávané prvkem.

Chcete-li převést iterátor s názvem Iter , který odkazuje na prvek v hash_multimap, použijte -> operátor.

Chcete-li získat přístup k hodnotě klíče pro prvek, použijte Iter->first, což je ekvivalentní (*Iter).first. Pro přístup k hodnotě mapovaného data pro prvek použijte Iter->second, což je ekvivalentní (*Iter).first.

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_multimap::key_comp

Poznámka:

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

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

key_compare key_comp() const;

Návratová hodnota

Vrátí objekt funkce, který hash_multimap používá k seřazení jeho prvků.

Poznámky

Uložený objekt definuje členovu funkci.

bool operator( const Key& left, const Key& right );

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

Příklad

// hash_multimap_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

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

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

hash_multimap::key_compare

Poznámka:

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

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

typedef Traits key_compare;

Poznámky

key_compare je synonymem parametru šablony Traits.

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

Příklad

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

hash_multimap::key_type

Poznámka:

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

Typ, který popisuje objekt klíče řazení, který představuje každý prvek hash_multimap.

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_multimap Třída .

Příklad

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

hash_multimap::lower_bound

Poznámka:

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

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

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametry

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

Návratová hodnota

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

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

Poznámky

Příklad

// hash_multimap_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> :: const_iterator hm1_AcIter,
      hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.lower_bound( 2 );
   cout << "The element of hash_multimap hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   hm1_RcIter = hm1.lower_bound( 3 );
   cout << "The first element of hash_multimap hm1 with a key of 3 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.lower_bound( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_multimap hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_multimap can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1.lower_bound( hm1_AcIter -> first );
   cout << "The first element of hm1 with a key matching"
        << endl << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;

   // Note that the first element with a key equal to
   // the key of the last element is not the last element
   if ( hm1_RcIter == --hm1.end( ) )
      cout << "This is the last element of hash_multimap hm1."
           << endl;
   else
      cout << "This is not the last element of hash_multimap hm1."
           << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::mapped_type

Poznámka:

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

Typ, který představuje datový typ uložený v hash_multimap.

typedef Type mapped_type;

Poznámky

mapped_typeje synonymem pro typ parametru šablony.

Další informace o typu naleznete v tématu hash_multimap Třída.

Příklad

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

hash_multimap::max_size

Poznámka:

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

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

size_type max_size() const;

Návratová hodnota

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

Poznámky

Příklad

// hash_multimap_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> :: size_type i;

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

hash_multimap::operator=

Poznámka:

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

Nahradí prvky hash_multimap kopií jiného hash_multimap.

hash_multimap& operator=(const hash_multimap& right);

hash_multimap& operator=(hash_multimap&& right);

Parametry

Vpravo
Zkopírovaný hash_multimap do souboru hash_multimap.

Poznámky

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

Příklad

// hash_multimap_operator_as.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   v1.insert(pair<int, int>(1, 10));

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

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

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

hash_multimap::p ointer

Poznámka:

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

Typ, který poskytuje ukazatel na prvek v hash_multimap.

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

hash_multimap::rbegin

Poznámka:

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

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Návratová hodnota

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

Poznámky

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

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

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

Příklad

// hash_multimap_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rbegin( );
   cout << "The first element of the reversed hash_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multimap in a forward order
   cout << "The hash_multimap is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( ); hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_multimap in a reverse order
   cout << "The reversed hash_multimap is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_multimap element can be erased by dereferencing its key
   hm1_rIter = hm1.rbegin( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rbegin( );
   cout << "After the erasure, the first element\n"
        << "in the reversed hash_multimap is "
        << hm1_rIter -> first << "." << endl;
}

The first element of the reversed hash_multimap hm1 is 3.
The hash_multimap is: 1 2 3 .
The reversed hash_multimap is: 3 2 1 .
After the erasure, the first element
in the reversed hash_multimap is 2.

hash_multimap::reference

Poznámka:

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

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

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

Poznámky

Příklad

// hash_multimap_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error as the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of first element in the hash_multimap is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of first element in the hash_multimap is "
        << Ref2 << "." << endl;

   //The non-const_reference can be used to modify the
   //data value of the first element
   Ref2 = Ref2 + 5;
   cout << "The modified data value of first element is "
        << Ref2 << "." << endl;
}

The key of first element in the hash_multimap is 1.
The data value of first element in the hash_multimap is 10.
The modified data value of first element is 15.

hash_multimap::rend

Poznámka:

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

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

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

Poznámky

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

Pokud je vrácená hodnota rend přiřazena const_reverse_iterator, nelze objekt hash_multimap změnit. Pokud je vrácená hodnota rend přiřazena reverse_iterator, lze objekt hash_multimap upravit.

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

Hodnota vrácená rend hodnotou by neměla být dereferenced.

Příklad

// hash_multimap_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "The last element of the reversed hash_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multimap in a forward order
   cout << "The hash_multimap is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( ); hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_multimap in a reverse order
   cout << "The reversed hash_multimap is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_multimap element can be erased by dereferencing its key
   hm1_rIter = --hm1.rend( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed hash_multimap is "
        << hm1_rIter -> first << "." << endl;
}

The last element of the reversed hash_multimap hm1 is 1.
The hash_multimap is: 1 2 3 .
The reversed hash_multimap is: 3 2 1 .
After the erasure, the last element in the reversed hash_multimap is 2.

hash_multimap::reverse_iterator

Poznámka:

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

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

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

Definovaný reverse_iterator hash_multimap odkazuje na objekty value_type, které jsou typu pair<const Key, Type.> Hodnota klíče je k dispozici prostřednictvím prvního páru členů a hodnota mapovaného prvku je k dispozici prostřednictvím druhého člena dvojice.

Příklad

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

hash_multimap::size

Poznámka:

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

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

size_type size() const;

Návratová hodnota

Aktuální délka hash_multimap.

Poznámky

Příklad

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

// hash_multimap_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1, hm2;
    hash_multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    i = hm1.size();
    cout << "The hash_multimap length is " << i << "." << endl;

    hm1.insert(Int_Pair(2, 4));
    i = hm1.size();
    cout << "The hash_multimap length is now " << i << "." << endl;
}

The hash_multimap length is 1.
The hash_multimap length is now 2.

hash_multimap::size_type

Poznámka:

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

Typ celého čísla bez znaménka, který spočítá počet prvků v hash_multimap.

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_multimap::swap

Poznámka:

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

Vymění prvky dvou hash_multimaps.

void swap(hash_multimap& right);

Parametry

Vpravo
Hash_multimap poskytnutí prvků, které mají být prohozeny, nebo hash_multimap, jejichž prvky se mají vyměňovat s prvky hash_multimap.

Poznámky

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

Příklad

// hash_multimap_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1, hm2, hm3;
   hash_multimap <int, int>::iterator hm1_Iter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );
   hm2.insert ( Int_Pair ( 10, 100 ) );
   hm2.insert ( Int_Pair ( 20, 200 ) );
   hm3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original hash_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hm1, hm3 );

   cout << "After swapping with hm3, hash_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

The original hash_multimap hm1 is: 10 20 30.
After swapping with hm2, hash_multimap hm1 is: 100 200.
After swapping with hm3, hash_multimap hm1 is: 300.

hash_multimap::upper_bound

Poznámka:

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

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

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametry

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

Návratová hodnota

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

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

Poznámky

Příklad

// hash_multimap_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );
   hm1.insert ( Int_Pair ( 3, 40 ) );

   hm1_RcIter = hm1.upper_bound( 1 );
   cout << "The 1st element of hash_multimap hm1 with "
        << "a key greater than 1 is: "
        << hm1_RcIter -> second << "." << endl;

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_multimap hm1\n"
        << "with a key greater than 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.lower_bound( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_multimap hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_multimap can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.begin( );
   hm1_RcIter = hm1.upper_bound( hm1_AcIter -> first );
   cout << "The first element of hm1 with a key greater than"
        << endl << "that of the initial element of hm1 is: "
        << hm1_RcIter -> second << "." << endl;
}

The 1st element of hash_multimap hm1 with a key greater than 1 is: 20.
The first element of hash_multimap hm1
with a key  greater than 2 is: 30.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key greater than
that of the initial element of hm1 is: 20.

hash_multimap::value_comp

Poznámka:

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

Členová funkce vrátí objekt funkce, který určuje pořadí prvků v hash_multimap porovnáním jejich klíčových hodnot.

value_compare value_comp() const;

Návratová hodnota

Vrátí objekt funkce porovnání, který hash_multimap používá k seřazení jeho prvků.

Poznámky

U hash_multimap m jsou dva prvky e1 (k1, d1) a e2(k2; d2) objekty typu value_type, kde k1 a k2 jsou jejich klíči typu key_type a d1 a d2 jsou jejich data typu mapped_type, pak m.value_comp()(e1, e2) je ekvivalentní m.key_comp()(k1, k2). Uložený objekt definuje členovou funkci.

bool operator( value_type& left, value_type& right);

vrátí true , pokud hodnota left klíče předcházející a není rovna hodnotě right klíče v pořadí řazení.

Příklad

// hash_multimap_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

   hash_multimap <int, int, hash_compare<int, less<int>>> hm1;
   hash_multimap <int, int, hash_compare<int, less<int>>
      >::value_compare vc1 = hm1.value_comp( );
   hash_multimap <int,int>::iterator Iter1, Iter2;

   Iter1= hm1.insert ( hash_multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= hm1.insert ( hash_multimap <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *Iter1, *Iter2 ) == true )
   {
      cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
           << endl;
   }
   else
   {
      cout << "The element ( 1,10 ) does "
           << "not precede the element ( 2,5 )."
           << endl;
   }

   if( vc1( *Iter2, *Iter1 ) == true )
   {
      cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
           << endl;
   }
   else
   {
      cout << "The element ( 2,5 ) does "
           << "not precede the element ( 1,10 )."
           << endl;
   }
}

hash_multimap::value_type

Poznámka:

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

Typ, který představuje typ objektu uloženého v hash_multimap.

typedef pair<const Key, Type> value_type;

Poznámky

value_type je deklarována jako dvojice<const key_type, mapped_type> a nikoli pár<key_type, mapped_type> , protože klíče asociativního kontejneru nemusí být změněny pomocí nekonstantního iterátoru nebo odkazu.

Příklad

// hash_multimap_value_type.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> :: key_type key1;
   hash_multimap <int, int> :: mapped_type mapped1;
   hash_multimap <int, int> :: value_type value1;
   hash_multimap <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   hm1.insert ( hash_multimap <int, int> :: value_type ( 1, 10 ) );

   // Compare another way to insert objects into a hash_multimap
   hm1.insert ( cInt2Int ( 2, 20 ) );

   // Initializing key1 and mapped1
   key1 = ( hm1.begin( ) -> first );
   mapped1 = ( hm1.begin( ) -> second );

   cout << "The key of first element in the hash_multimap is "
        << key1 << "." << endl;

   cout << "The data value of first element in the hash_multimap is "
        << mapped1 << "." << endl;

   // The following line would cause an error because
   // the value_type is not assignable
   // value1 = cInt2Int ( 4, 40 );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;
}

The key of first element in the hash_multimap is 1.
The data value of first element in the hash_multimap is 10.
The keys of the mapped elements are: 1 2.
The values of the mapped elements are: 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_multimap – třída

Syntaxe

Parametry

Poznámky

Konstruktory

Typedefs

Členské funkce

Operátory

Požadavky

hash_multimap::allocator_type

Poznámky

Příklad

hash_multimap::begin

Návratová hodnota

Poznámky

Příklad

hash_multimap::cbegin

Návratová hodnota

Příklad

hash_multimap::cend

Návratová hodnota

Poznámky

Příklad

hash_multimap::clear

Poznámky

Příklad

hash_multimap::const_iterator

Poznámky

Příklad

hash_multimap::const_pointer

Poznámky

hash_multimap::const_reference

Poznámky

Příklad

hash_multimap::const_reverse_iterator

Poznámky

Příklad

hash_multimap::count

Parametry

Návratová hodnota

Poznámky

Příklad

hash_multimap::crbegin

Návratová hodnota

Poznámky

Příklad

hash_multimap::crend

Návratová hodnota

Poznámky

Příklad

hash_multimap::d ifference_type

Poznámky

Příklad

hash_multimap::emplace

Parametry

Návratová hodnota

Poznámky

Příklad

hash_multimap::emplace_hint

Parametry

Návratová hodnota

Poznámky

Příklad

hash_multimap::empty

Návratová hodnota

Poznámky

Příklad

hash_multimap::end

Návratová hodnota

Poznámky

Příklad

hash_multimap::equal_range

Parametry

Návratová hodnota

Poznámky

Příklad

hash_multimap::erase

Parametry

Návratová hodnota