`hash_map` Třída

Článek
07/05/2024

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Ukládá a načítá data rychle z kolekce, ve které je každý prvek dvojicí, která má klíč řazení, jehož hodnota je 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_map

Parametry

Key
Datový typ klíče, který má být uložen v souboru hash_map.

Type
Datový typ prvku, který má být uložen v souboru hash_map.

Traits
Typ, který obsahuje dva objekty funkce, jeden z tříd porovnávat dvě hodnoty prvků jako klíče řazení určit jejich relativní 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 hash_compare<Key, less<Key>> je výchozí hodnotou.

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

Poznámky

Jedná se o hash_map :

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ů.
Jedinečný v tom smyslu, že každý z jeho prvků musí mít jedinečný klíč.
Kontejner asociativních párů, protože jeho prvky hodnoty dat se liší od hodnot klíčů.
Š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 objektu hash_map, ale ne jeho 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).

Tento hash_map kontejner by měl být asociativním kontejnerem podle výběru, když aplikace podmínky přidružuje hodnoty k jejich klíčům. Model pro tento typ struktury je uspořádaný seznam jedinečných klíčových slov s přidruženými řetězcovými hodnotami poskytujícími definice. Pokud by místo toho slova měla více než jednu správnou definici, takže klíče nebyly jedinečné, pak hash_multimap by byl kontejner podle výběru. Pokud by se na druhou stranu ukládaly jenom seznam slov, pak hash_set by to byl správný kontejner. Pokud bylo povoleno více výskytů slov, pak hash_multiset by byla vhodná struktura kontejneru.

Pořadí hash_map , které řídí voláním uloženého objektu hash Traits třídy value_compare. K tomuto uloženému objektu lze získat přístup 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 Key, volání Traits( Key ) dává rozdělení hodnot typu size_t. Další informace najdete na webu hash_compare.

Obecně platí, že prvky musí být pouze menší než srovnatelné pro stanovení tohoto pořadí: takže vzhledem ke všem dvěma prvkům může být zjištěno, že jsou ekvivalentní (ve smyslu, že ani jeden není menší než 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 návratovou hodnotu true nebo false. Řazení uložené na straně je hash_map striktní slabé řazení, pokud je binární predikát neflexivní, antisymetrické a tranzitivní a je-li ekvivalence tranzitivní, kde jsou dva objekty a y jsou definovány x jako ekvivalentní, pokud jsou oba 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 nemůžete určit, takže nemůžete obecně 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_map třídou je obousměrný iterátor, ale členské funkce insert třídy a hash_map mají verze, které berou jako parametry šablony slabší vstupní iterátor, jehož požadavky na funkčnost jsou více minimální než ty, které zaručuje třída obousměrných iterátorů. Různé koncepty iterátorů tvoří rodinu týkající se upřesnění jejich funkčnosti. Každý koncept iterátoru má vlastní sadu požadavků a algoritmy, které s nimi pracují, musí omezit jejich předpoklady na požadavky podle typu iterátoru. Lze předpokládat, že ke vstupnímu iterátoru lze přistoupit přes ukazatel pro odkazování na některý objekt a že může být zvýšen na další iterátor v pořadí. Jedná se o minimální sadu funkcí, ale stačí, abyste mohli smysluplně mluvit o rozsahu iterátorů [First, Last) v kontextu členských funkcí třídy.

Konstruktory

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

Typedefs

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

Členské funkce

Členová funkce	Popis
`at`	Vyhledá prvek v objektu `hash_map` se zadanou hodnotou klíče.
`begin`	Vrátí iterátor adresování prvního prvku v objektu `hash_map`.
`cbegin`	Vrátí konstantní iterátor adresování prvního prvku v objektu `hash_map`.
`cend`	Vrátí iterátor const, který řeší umístění úspěšné poslední prvek v objektu `hash_map`.
`clear`	Vymaže všechny prvky .`hash_map`
`count`	Vrátí počet prvků v `hash_map` klíči, jehož klíč odpovídá klíči zadanému parametrem.
`crbegin`	`const` Vrátí iterátor adresovaný prvním prvkem v obráceném směru `hash_map`.
`crend`	`const` Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu `hash_map`.
`emplace`	Vloží prvek vytvořený na místě do objektu `hash_map`.
`emplace_hint`	Vloží prvek vytvořený na místě do objektu `hash_map`, s tipem umístění.
`empty`	Testuje, jestli `hash_map` je prázdný.
`end`	Vrátí iterátor, který řeší umístění úspěšné poslední prvek v objektu `hash_map`.
`equal_range`	Vrátí dvojici iterátorů v uvedeném pořadí k prvnímu prvku v `hash_map` klíči, který je větší než zadaný klíč, a k prvnímu prvku v `hash_map` klíči, který je roven nebo větší než klíč.
`erase`	Odebere prvek nebo rozsah prvků v `hash_map` zadaných pozicích.
`find`	Vrátí iterátor adresovaný umístění prvku v objektu `hash_map` , který má klíč ekvivalentní zadanému klíči.
`get_allocator`	Vrátí kopii objektu `allocator` použitého k vytvoření objektu `hash_map`.
`insert`	Vloží prvek nebo oblast prvků do objektu `hash_map`.
`key_comp`	Vrátí iterátor na první prvek v `hash_map` klíči s hodnotou klíče, která je rovna nebo větší než zadaný klíč.
`lower_bound`	Vrátí iterátor na první prvek v `hash_map` klíči s hodnotou klíče, která je rovna nebo větší než zadaný klíč.
`max_size`	Vrátí maximální délku `hash_map`.
`rbegin`	Vrátí iterátor adresovaný prvním prvkem v obráceném směru `hash_map`.
`rend`	Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu `hash_map`.
`size`	Vrátí počet prvků v sadě `hash_map`.
`swap`	Vymění prvky dvou `hash_map`s.
`upper_bound`	Vrátí iterátor na první prvek v objektu `hash_map` , 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_map`.

Operátory

Operátor	Popis
`operator[]`	Vloží prvek do objektu `hash_map` se zadanou hodnotou klíče.
`hash_map::operator=`	Nahradí prvky jiného `hash_map` souboru kopií jiného `hash_map`.

Požadavky

Záhlaví: <hash_map>

Obor názvů: stdext

`hash_map::allocator_type`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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

Příklad

Příklad get_allocator použití .allocator_type

`hash_map::at`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vyhledá prvek v objektu hash_map se zadanou hodnotou klíče.

Type& at(const Key& key);

const Type& at(const Key& key) const;

Parametry

key
Hodnota klíče prvku, který se má najít.

Návratová hodnota

Odkaz na datovou hodnotu nalezeného prvku.

Poznámky

Pokud se hodnota klíče argumentu nenajde, funkce vyvolá objekt třídy out_of_range Class.

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;

   // Insert data values
   hm1.insert ( cInt2Int ( 1, 10 ) );
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The values of the mapped elements are:";
   for ( int i = 1 ; i <= hm1.size() ; i++ )
      cout << " " << hm1.at(i);
   cout << "." << endl;
}

`hash_map::begin`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

const_iterator begin() const;

iterator begin();

Návratová hodnota

Obousměrný iterátor adresující první prvek v hash_map umístění, které je úspěšné prázdné hash_map.

Příklad

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

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

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <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_map::cbegin`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

const_iterator cbegin() const;

Návratová hodnota

Const obousměrný iterátor adresující první prvek v hash_map umístění, které je úspěšné prázdné hash_map.

Příklad

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

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

   hash_map <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_map::cend`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

const_iterator cend() const;

Návratová hodnota

Obousměrný iterátor, který řeší umístění úspěšného posledního prvku v objektu hash_map. hash_map Pokud je prázdný, pak hash_map::cend == hash_map::begin.

Poznámky

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

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

Příklad

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

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

   hash_map <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_map::clear`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vymaže všechny prvky .hash_map

void clear();

Poznámky

Příklad

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

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

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<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_map is initially "
         << i << "." << endl;

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

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

`hash_map::const_iterator`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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

Definované const_iterator hash_map body na prvky, které jsou objekty value_type, který je typu pair< const Key, Type >, jehož první člen je klíčem k prvku a jehož druhý člen je mapovaný datum uchovávané prvkem.

Pokud chcete odkazovat const_iterator cIter na prvek v objektu hash_map, 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

Příklad begin použití .const_iterator

`hash_map::const_pointer`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Typ, který poskytuje ukazatel na const prvek v objektu hash_map.

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

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

`hash_map::const_reference`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<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 the first element in the hash_map 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 the first element in the hash_map is "
        << Ref2 << "." << endl;
}

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

`hash_map::const_reverse_iterator`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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 elementu a používá se k iteraci obráceně hash_map .

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

Pokud chcete odkazovat const_reverse_iterator crIter na prvek v objektu hash_map, 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).first.

Příklad

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

`hash_map::count`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

size_type count(const Key& key) const;

Parametry

key
Hodnota klíče prvků, které se mají shodovat s hash_maphodnotou .

Návratová hodnota

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

Poznámky

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

lower_bound(key), upper_bound(key)

což je 0 nebo 1 v případě hash_map, což je jedinečný asociativní kontejner.

Příklad

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

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<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));

    // Keys must be unique in hash_map, so duplicates are ignored
    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: 1.
The number of elements in hm1 with a sort key of 2 is: 1.
The number of elements in hm1 with a sort key of 3 is: 0.

`hash_map::crbegin`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

const Vrátí iterátor adresovaný prvním prvkem v obráceném směru hash_map.

const_reverse_iterator crbegin() const;

Návratová hodnota

const Reverzní obousměrný iterátor adresovaný prvním prvkem v obráceném hash_map směru nebo adresování toho, co bylo posledním prvkem v nereverze .hash_map

Poznámky

crbegin se používá s obráceným opakem hash_map , stejně jako begin se používá s hash_map.

S návratovou crbeginhash_map hodnotou objektu nelze změnit.

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

Příklad

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

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

   hash_map <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_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.

`hash_map::crend`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

const_reverse_iterator crend() const;

Návratová hodnota

Reverzní const obousměrný iterátor, který adresuje umístění úspěšné poslední prvek v obráceném hash_map směru (umístění, které předchází prvnímu prvku v nereverze hash_map).

Poznámky

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

S návratovou crendhash_map hodnotou objektu nelze změnit.

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

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

Příklad

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

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

   hash_map <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_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 3.

`hash_map::difference_type`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <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 won't insert, because map keys are unique
   hm1.insert ( Int_Pair ( 2, 30 ) );

   hash_map <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_map
   hash_map <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_map 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_map hm1 is: 3.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 20.

`hash_map::emplace`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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

Parametry

val
Hodnota použitá k přesunutí konstruktoru, který se má vložit do objektu hash_map hash_map , pokud již tento prvek neobsahuje (obecněji prvek, jehož klíč je ekvivalentní seřazený).

Návratová hodnota

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

Chcete-li získat přístup ke iterator komponentě páru pr vrácené touto členovou funkcí, použijte pr.firsta k jeho dereferenci použijte *(pr.first). Chcete-li získat přístup ke bool komponentě páru pr vrácené touto členovou funkcí, použijte pr.seconda k jeho dereferenci použijte *(pr.second).

Poznámky

Prvek hash_map::value_type 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_map_emplace.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

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

    hm1.emplace(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_map::emplace_hint`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vloží prvek vytvořený na místě do objektu hash_map, s tipem umístění.

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

Parametry

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

Návratová hodnota

Členová hash_multimap::emplace funkce vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do objektu hash_map, nebo kde se nachází existující prvek s ekvivalentním řazením.

Poznámky

Prvek hash_map::value_type 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_map_emplace_hint.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

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

    hm1.emplace(hm1.begin(), 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_map::empty`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Testuje, jestli hash_map je prázdný.

bool empty() const;

Návratová hodnota

truehash_map pokud je prázdný; false pokud hash_map je neprázdný.

Poznámky

Příklad

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

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

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

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

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

The hash_map hm1 is not empty.
The hash_map hm2 is empty.

`hash_map::end`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

const_iterator end() const;

iterator end();

Návratová hodnota

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

Poznámky

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

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

Příklad

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

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

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <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_map::equal_range`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

Návratová hodnota

Pár iterátorů tak, aby první je lower_bound klíč a druhý je upper_bound klíč.

Chcete-li získat přístup k prvnímu iterátoru dvojice pr vrácené členovou funkcí, použijte pr.first a pro dereference dolního vázaného iterátoru použijte *(pr.first). Chcete-li získat přístup k druhému iterátoru dvojice pr vrácené členovou funkcí, použijte pr.second a pro dereference horního vázaného iterátoru použijte *(pr.second).

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_map <int, int> IntMap;
   IntMap hm1;
   hash_map <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 <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

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

   cout << "The upper bound of the element with "
        << "a key of 2 in the hash_map 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_map hm1 doesn't have an element "
             << "with a key less than 40." << endl;
   else
      cout << "The element of hash_map hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2 in the hash_map hm1 is: 20.
The upper bound of the element with a key of 2 in the hash_map 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_map hm1 doesn't have an element with a key less than 40.

`hash_map::erase`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Odebere prvek nebo rozsah prvků v hash_map zadané pozici 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

_Where
Pozice prvku, který má být odebrán z objektu hash_map.

first
Pozice prvního prvku odebraného z objektu hash_map.

last
Pozice těsně za posledním prvkem odebranými z objektu hash_map.

key
Hodnota klíče prvků, které mají být odebrány z objektu hash_map.

Návratová hodnota

Pro první dvě členské funkce, obousměrný iterátor, který určuje první prvek, který zůstává nad rámec všech odebraných prvků, nebo ukazatel na konec hash_map , pokud žádný takový prvek neexistuje.

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

Poznámky

Členské funkce nikdy nevyvolají výjimku.

Příklad

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

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2, hm3;
    hash_map<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_map<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_map 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_map 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
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_map 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"
         << endl;
    cout  << "of the 2nd element is deleted, "
          << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

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

`hash_map::find`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Hodnota klíče, která se má shodovat s klíčem řazení prvku z prohledávaného hash_map prvku.

Návratová hodnota

Iterátor, který řeší umístění elementu se zadaným klíčem, nebo umístění, které uspělo s posledním prvkem v hash_map případě, že se pro klíč nenajde žádná shoda.

Poznámky

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

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <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_RcIter = hm1.find( 2 );
   cout << "The element of hash_map hm1 with a key of 2 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_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map 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 element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

`hash_map::get_allocator`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

Allocator get_allocator() const;

Návratová hodnota

Alokátor používaný hash_map.

Poznámky

Alokátory pro hash_map 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_map_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

   // The following lines declare objects
   // that use the default allocator.
   hash_map <int, int> hm1;
   hash_map <int, int> hm2;
   hash_map <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_map hm4
   // with the allocator of hash_map hm1.
   hash_map <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

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

`hash_map::hash_map`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

hash_map();

explicit hash_map(
    const Traits& Comp);

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

hash_map(
    const hash_map& Right);

hash_map(
    hash_map&& Right);

hash_map(
    initializer_list<Type> IList);hash_map(initializer_list<Type> IList,
    const key_compare& Comp);

hash_map(
    initializer_list<Type> IList,
    const key_compare& Comp,
    const allocator_type& Al);

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

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

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al

Parametry

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

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

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

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

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

IList
initializer_list

Poznámky

Všechny konstruktory ukládají typ objektu alokátoru, který spravuje úložiště paměti pro danou hash_map a lze později vrátit voláním 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_map.

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

První tři konstruktory určují prázdný počáteční hash_map, kromě toho 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_map Right.

Další tři konstruktory zkopírují rozsah [First, Last) hash_map s rostoucí explicitností při zadávání typu porovnávací funkce třídy Traits a alokátoru.

Poslední konstruktor přesune hash_map Right.

`hash_map::insert`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vloží prvek nebo oblast prvků do objektu hash_map.

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

iterator insert(
    const_iterator _Where,
    const value_type& val);

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

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

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

Parametry

val
Hodnota prvku, který se má vložit do hash_map prvku, pokud hash_map již tento prvek neobsahuje (obecněji prvek, jehož klíč je odpovídajícím způsobem seřazený).

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

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

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

Návratová hodnota

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

Chcete-li získat přístup ke komponentě iterátoru páru pr vrácené touto členovou funkcí, použijte pr.firsta k jeho dereferenci použijte (pr.first). Chcete-li získat přístup ke bool komponentě páru pr vrácené touto členovou funkcí, použijte pr.seconda k jeho dereferenci použijte \(pr.second).

Druhá insert členová funkce, verze nápovědy, vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do hash_map.

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

Poznámky

Prvek value_type 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é konstantní době pro verzi nápovědy vložení místo logaritmického času, pokud kurzor bezprostředně následuje _Where.

Třetí člen funkce vloží sekvenci hodnot prvků do hash_map odpovídajících prvků adresovaných iterátorem v rozsahu *[First, Last)* zadané sady.

Příklad

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int>::iterator hm1_pIter, hm2_pIter;

    hash_map<int, int> hm1, hm2;
    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(4, 40));

    cout << "The original elements (Key => Value) of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << " " << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    pair< hash_map<int,int>::iterator, bool > pr;
    pr = hm1.insert(Int_Pair(1, 10));

    if (pr.second == true)
    {
        cout << "The element 10 was inserted in hm1 successfully."
            << endl;
    }
    else
    {
        cout << "The element 10 already exists in hm1\n"
            << "with a key value of "
            << "((pr.first) -> first) = " << (pr.first)->first
            << "." << endl;
    }

    // The hint version of insert
    hm1.insert(--hm1.end(), Int_Pair(5, 50));

    cout << "After the insertions, the elements of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    hm2.insert(Int_Pair(10, 100));

    // The templatized version inserting a range
    hm2.insert( ++hm1.begin(), --hm1.end() );

    cout << "After the insertions, the elements of hm2 are:";
    for (hm2_pIter = hm2.begin(); hm2_pIter != hm2.end(); hm2_pIter++)
        cout << endl << hm2_pIter -> first << " => "
             << hm2_pIter->second;
    cout << endl;

    // The templatized versions move constructing elements
    hash_map<int, string> hm3, hm4;
    pair<int, string> is1(1, "a"), is2(2, "b");

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

    hm4.insert(hm4.begin(), move(is2));
    cout << "After the move insertion, hm4 contains:" << endl
      << hm4.begin()->first
      << " => " << hm4.begin()->second
      << endl;
}

The original elements (Key => Value) of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
The element 10 already exists in hm1
with a key value of ((pr.first) -> first) = 1.
After the insertions, the elements of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
5 => 50
After the insertions, the elements of hm2 are:
2 => 20
10 => 100
3 => 30
4 => 40
After the move insertion, hm3 contains:
1 => a
After the move insertion, hm4 contains:
2 => b

`hash_map::iterator`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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

Poznámky

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

Pokud chcete převést iterátor s názvem Iter odkazující na prvek ve vícemapách, 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).second.

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

Příklad

begin Příklad, jak deklarovat a používat iterator.

`hash_map::key_comp`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

key_compare key_comp() const;

Návratová hodnota

Vrátí objekt funkce, který hash_map 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í rovno right v pořadí řazení.

Příklad

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

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

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >::key_compare
      kc1 = hm1.key_comp( ) ;

   // Operator stored in kc1 tests order & returns bool value
   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"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }

   hash_map <int, int, hash_compare<int, greater<int> > > hm2;
   hash_map <int, int, hash_compare<int, greater<int> > >
      ::key_compare kc2 = hm2.key_comp( );

   // Operator stored in kc2 tests order & returns bool value
   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"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
}

`hash_map::key_compare`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

typedef Traits key_compare;

Poznámky

key_compare je synonymem parametru Traitsšablony .

Další informace o Traits hash_map tématu Třída.

Příklad

key_comp Příklad, jak deklarovat a používat key_compare.

`hash_map::key_type`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

typedef Key key_type;

Poznámky

key_type je synonymem parametru Keyšablony .

Další informace naleznete Keyv části Poznámky tématu předmětuhash_map.

Příklad

value_type Příklad, jak deklarovat a používat key_type.

`hash_map::lower_bound`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vrátí iterátor na první prvek v hash_map klíči s hodnotou klíče, která je rovna nebo větší než zadaný klíč.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametry

key
Hodnota klíče argumentu, která se má porovnat s klíčem řazení prvku z prohledávaného hash_map prvku.

Návratová hodnota

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

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

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <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_RcIter = hm1.lower_bound( 2 );
   cout << "The first element of hash_map hm1 with a key of 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_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // An element at a specific location in the hash_map 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 element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

`hash_map::mapped_type`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

typedef Type mapped_type;

Poznámky

Typ mapped_type je synonymem pro parametr Typešablony .

Další informace o Type hash_map tématu Třída.

Příklad

value_type Příklad, jak deklarovat a používat key_type.

`hash_map::max_size`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

size_type max_size() const;

Návratová hodnota

Maximální možnou délku hash_map.

Poznámky

Příklad

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

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

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

`hash_map::operator[]`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vloží prvek do objektu hash_map se zadanou hodnotou klíče.

Type& operator[](const Key& key);

Type& operator[](Key&& key);

Parametry

key
Hodnota klíče prvku, který má být vložen.

Návratová hodnota

Odkaz na hodnotu dat vloženého prvku.

Poznámky

Pokud se hodnota klíče argumentu nenajde, vloží se spolu s výchozí hodnotou datového typu.

operator[]lze použít k vložení prvků do hash_map m

m[ key] = DataValue;

where DataValue je hodnota mapped_type prvku s hodnotou keyklíče .

Při použití operator[] k vložení prvků vrácený odkaz nezoznačuje, jestli vložení mění existující prvek nebo vytváří nový. Členské funkce find a insert lze je použít k určení, zda prvek se zadaným klíčem již existuje před vložením.

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: iterator pIter;

   // Insert a data value of 10 with a key of 1
   // into a hash_map using the operator[] member function
   hm1[ 1 ] = 10;

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( hash_map <int, int> :: value_type ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   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;

   // If the key already exists, operator[]
   // changes the value of the datum in the element
   hm1[ 2 ] = 40;

   // operator[] will also insert the value of the data
   // type's default constructor if the value is unspecified
   hm1[5];

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

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

   // operator[] will also insert by moving a key
   hash_map <string, int> hm2;
   string str("a");
   hm2[move(str)] = 1;
   cout << "The moved key is " << hm2.begin()->first
      << ", with value " << hm2.begin()->second << endl;
}

`hash_map::operator=`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Nahradí prvky jiného hash_map hash_map.

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

Parametry

right
Třídaright, která se kopíruje do objektu hash_map.

Poznámky

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

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> v1, v2, v3;
   hash_map<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_map::pointer`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Typ, který poskytuje ukazatel na prvek v objektu hash_map.

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ů iterator by se měla použít pro přístup k prvkům v objektu hash_map .

`hash_map::rbegin`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vrátí iterátor adresovaný prvním prvkem v obráceném směru hash_map.

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_map směru nebo adresování toho, co bylo posledním prvkem v nereverze .hash_map

Poznámky

rbegin se používá s obráceným opakem hash_map , stejně jako begin se používá s hash_map.

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

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

Příklad

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

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

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <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_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map 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_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

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

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

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

`hash_map::reference`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <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_map 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_map 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_map is 1.
The data value of first element in the hash_map is 10.
The modified data value of first element is 15.

`hash_map::rend`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Návratová hodnota

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

Poznámky

rend se používá s obráceným opakem hash_map , stejně jako end se používá s hash_map.

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iterator, hash_map nelze objekt upravit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iterator, hash_map lze objekt upravit.

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

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

Příklad

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

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

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <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_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map 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_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( );
      hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to 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_map is "
        << hm1_rIter -> first << "." << endl;
}

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

`hash_map::reverse_iterator`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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

Poznámky

Typ reverse_iterator nemůže změnit hodnotu elementu a používá se k iteraci obráceně hash_map .

Definované reverse_iterator hash_map body na prvky, které jsou objekty value_type, to je typ pair<const Key, Type>, jehož první člen je klíčem k prvku a jehož druhý člen je mapovaný datum uchovávané prvkem.

Pokud chcete odkazovat reverse_iterator rIter na prvek v objektu hash_map, použijte -> operátor.

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

Příklad

rbegin Příklad, jak deklarovat a používat reverse_iterator.

`hash_map::size`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vrátí počet prvků v sadě hash_map.

size_type size() const;

Návratová hodnota

Aktuální délka hash_map.

Poznámky

Příklad

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

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

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

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

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

The hash_map length is 1.
The hash_map length is now 2.

`hash_map::size_type`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

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í najdete v příkladu size postupu deklarace a použití. size_type

`hash_map::swap`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vymění prvky dvou hash_maps.

void swap(hash_map& right);

Parametry

right
hash_map Argument poskytující prvky, které mají být prohozeny s cílem hash_map.

Poznámky

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

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2, hm3;
   hash_map <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_map 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
   // hm2 is said to be the argument hash_map;
   // hm1 is said to be the target hash_map
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_map 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_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

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

`hash_map::upper_bound`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vrátí iterátor na první prvek v objektu hash_map s klíčem, který má hodnotu větší než zadaný klíč.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametry

key
Hodnota klíče argumentu, která se má porovnat s hodnotou klíče řazení prvku z prohledávaného hash_map prvku.

Návratová hodnota

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

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

Poznámky

Příklad

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <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_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_map hm1 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. upper_bound ( 4 );

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

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

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

`hash_map::value_comp`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

Vrátí objekt funkce, který určuje pořadí prvků v objektu hash_map porovnáním jejich klíčových hodnot.

value_compare value_comp() const;

Návratová hodnota

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

Poznámky

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

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

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

Příklad

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

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

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >
   ::value_compare vc1 = hm1.value_comp( );
   pair< hash_map<int,int>::iterator, bool > pr1, pr2;

   pr1= hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );
   pr2= hm1.insert ( hash_map <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *pr1.first, *pr2.first ) == 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 ( *pr2.first, *pr1.first ) == 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_map::value_type`

Poznámka:

Toto rozhraní API je zastaralé. Alternativou je unordered_map Třída.

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

typedef pair<const Key, Type> value_type;

Poznámky

value_type je deklarován pair<const key_type, mapped_type> jako a ne pair<key_type, mapped_type> proto, že klíče asociativního kontejneru nelze změnit pomocí nekonstantního iterátoru nebo odkazu.

Příklad

// hash_map_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_map <int, int> hm1;
   hash_map <int, int> :: key_type key1;
   hash_map <int, int> :: mapped_type mapped1;
   hash_map <int, int> :: value_type value1;
   hash_map <int, int> :: iterator pIter;

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

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1[ 3 ] = 30;

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

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

   cout << "The data value of first element in the hash_map 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_map is 1.
The data value of first element in the hash_map is 10.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.

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

Syntaxe

Parametry

Poznámky

Konstruktory

Typedefs

Členské funkce

Operátory

Požadavky

hash_map::allocator_type

Příklad

hash_map::at

Parametry

Návratová hodnota

Poznámky

Příklad

hash_map::begin

Návratová hodnota

Příklad

hash_map::cbegin

Návratová hodnota

Příklad

hash_map::cend

Návratová hodnota

Poznámky

Příklad

hash_map::clear

Poznámky

Příklad

hash_map::const_iterator

Poznámky

Příklad

hash_map::const_pointer

Poznámky

hash_map::const_reference

Poznámky

Příklad

hash_map::const_reverse_iterator

Poznámky

Příklad

hash_map::count

Parametry

Návratová hodnota

Poznámky

Příklad

hash_map::crbegin

Návratová hodnota

Poznámky

Příklad

hash_map::crend

Návratová hodnota

Poznámky

Příklad

hash_map::difference_type

Příklad

hash_map::emplace

Parametry

Návratová hodnota

Poznámky

Příklad

hash_map::emplace_hint

Parametry

Návratová hodnota

Poznámky

Příklad

hash_map::empty

Návratová hodnota

Poznámky

Příklad

hash_map::end

Návratová hodnota

Poznámky

Příklad

hash_map::equal_range

Parametry

Návratová hodnota

Poznámky

Příklad

hash_map::erase

`hash_map` Třída

`hash_map::allocator_type`

`hash_map::at`

`hash_map::begin`

`hash_map::cbegin`

`hash_map::cend`

`hash_map::clear`

`hash_map::const_iterator`

`hash_map::const_pointer`

`hash_map::const_reference`

`hash_map::const_reverse_iterator`

`hash_map::count`

`hash_map::crbegin`

`hash_map::crend`

`hash_map::difference_type`

`hash_map::emplace`

`hash_map::emplace_hint`

`hash_map::empty`

`hash_map::end`

`hash_map::equal_range`

`hash_map::erase`

`hash_map::find`

`hash_map::get_allocator`

`hash_map::hash_map`

`hash_map::insert`

`hash_map::iterator`

`hash_map::key_comp`

`hash_map::key_compare`

`hash_map::key_type`

`hash_map::lower_bound`

`hash_map::mapped_type`

`hash_map::max_size`

`hash_map::operator[]`

`hash_map::operator=`

`hash_map::pointer`

`hash_map::rbegin`

`hash_map::reference`

`hash_map::rend`

`hash_map::reverse_iterator`