hash_map Klasa

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Przechowuje i pobiera dane szybko z kolekcji, w której każdy element jest parą, która ma klucz sortowania, którego wartość jest unikatowa i skojarzona wartość danych.

Składnia

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

Parametry

Key
Typ danych klucza, który ma być przechowywany w obiekcie hash_map.

Type
Typ danych elementu, który ma być przechowywany w obiekcie hash_map.

Traits
Typ, który zawiera dwa obiekty funkcji, jeden z klas porównujących, może porównać dwie wartości elementów jako klucze sortowania w celu określenia ich względnej kolejności i funkcji skrótu, która jest jednoargumentowym mapowaniem wartości klucza elementów na niepodpisane liczby całkowite typu size_t. Ten argument jest opcjonalny i hash_compare<Key, less<Key>> jest wartością domyślną.

Allocator
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące hash_mapalokacji i cofania przydziału pamięci. Ten argument jest opcjonalny, a wartość domyślna to allocator<pair <const Key, Type>>.

Uwagi

Element hash_map to:

• Kontenerem asocjacyjnym, który jest kontenerem o zmiennym rozmiarze, obsługującym efektywne pobieranie wartości elementu w oparciu o wartość skojarzonego klucza.

• Odwracalny, ponieważ zapewnia dwukierunkowy iterator do dostępu do jego elementów.

• Skrót, ponieważ jego elementy są pogrupowane w zasobniki na podstawie wartości funkcji skrótu zastosowanej do kluczowych wartości elementów.

• Unikatowy w tym sensie, że każdy z jego elementów musi mieć unikatowy klucz.

• Kontenerem skojarzonych par, ponieważ jej wartości danych elementu różnią się od wartości klucza.

• Szablon klasy, ponieważ funkcje, które udostępnia, są ogólne i tak niezależne od określonego typu danych zawartych jako elementy lub klucze. Typy danych, których można użyć dla elementów i kluczy, są zamiast tego określane jako parametry w szablonie klasy, wraz z funkcją porównania oraz alokatorem.

Główną zaletą tworzenia skrótów w sortowaniu jest większa wydajność; Pomyślne utworzenie skrótu wykonuje operacje wstawiania, usuwania i znajduje się w stałym średnim czasie w porównaniu z czasem proporcjonalnym do logarytmu liczby elementów w kontenerze na potrzeby technik sortowania. Wartość elementu w elemecie hash_map, ale nie skojarzona z nią wartość klucza, może zostać zmieniona bezpośrednio. Zamiast tego, wartości kluczy skojarzone ze starymi elementami muszą zostać usunięte, a nowe wartości klucza skojarzone z nowymi wstawionymi elementami.

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

Element hash_map powinien być wybranym kontenerem asocjacyjnym, gdy warunki kojarzenia wartości z kluczami są spełnione przez aplikację. Model dla tego typu struktury to uporządkowana lista unikatowych słów kluczowych ze skojarzonymi wartościami ciągów, na przykład definicjami. Jeśli zamiast tego wyrazy miały więcej niż jedną poprawną definicję, tak aby klucze nie były unikatowe, byłby to hash_multimap wybrany kontener. Jeśli z drugiej strony tylko lista wyrazów była przechowywana, będzie hash_set to prawidłowy kontener. Jeśli dozwolone jest wiele wystąpień wyrazów, odpowiednia hash_multiset struktura kontenera będzie odpowiednia.

Kolejność hash_map steruje sekwencją przez wywołanie przechowywanego obiektu skrótu Traits klasy value_compare. Dostęp do tego przechowywanego obiektu można uzyskać, wywołując funkcję key_compskładową . Taki obiekt funkcji musi zachowywać się tak samo jak obiekt klasy hash_compare<Key, less<Key>>. W szczególności dla wszystkich wartości Key typu Keywywołanie Traits( Key ) zwraca rozkład wartości typu size_t. Aby uzyskać więcej informacji, zobacz hash_compare.

Ogólnie rzecz biorąc, elementy muszą być jedynie mniej niż porównywalne do ustalenia tej kolejności: tak aby, biorąc pod uwagę dwa elementy, można określić, że są one równoważne (w sensie, że ani nie jest mniejszy niż drugi) lub że jeden jest mniejszy niż drugi. Skutkuje to ustaleniem kolejności dla elementów nierównoważnych. Ze strony bardziej technicznej, funkcja porównywania jest predykatem binarnym, który wymusza ścisłe słabe porządkowanie w standardowym sensie matematycznym. Predykat binarny f(x y) jest obiektem funkcji, który ma dwa obiekty argumentów x i y zwracaną wartość true lub false. Kolejność nałożona na element hash_map to ścisłe słabe porządkowanie, jeśli predykat binarny jest nieelastycznym, antysymetrycznym i przechodniym, a jeśli równoważność jest przechodnia, gdzie dwa obiekty x i y są zdefiniowane jako równoważne, gdy oba f(x, y) i f(y, x) są false. Jeśli silniejszy warunek równości pomiędzy kluczami zastąpi ten równoważności, to porządkowanie będzie całkowite (w sensie, że wszystkie elementy są uporządkowane względem siebie), a dopasowane klucze będą od siebie nieodróżnialne.

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

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

Konstruktory

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

Typedefs

Nazwa typu	opis
allocator_type	Typ reprezentujący klasę allocator hash_map dla obiektu.
const_iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytać const element w obiekcie hash_map.
const_pointer	Typ, który dostarcza wskaźnik do const elementu w obiekcie hash_map.
const_reference	Typ, który zawiera odwołanie do elementu przechowywanego const w hash_map obiekcie do odczytu i wykonywania const operacji.
const_reverse_iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny const element w obiekcie hash_map.
difference_type	Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów hash_map w zakresie między elementami wskazywanym przez iteratory.
iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować dowolny element w obiekcie hash_map.
key_compare	Typ, który udostępnia obiekt funkcji, który może porównać dwa klucze sortowania, aby określić względną kolejność dwóch elementów w obiekcie hash_map.
key_type	Typ opisuje obiekt klucza sortowania, który stanowi każdy element obiektu hash_map.
mapped_type	Typ reprezentujący typ danych przechowywany w obiekcie hash_map.
pointer	Typ, który dostarcza wskaźnik do elementu w elemecie hash_map.
reference	Typ, który zawiera odwołanie do elementu przechowywanego w obiekcie hash_map.
reverse_iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować element w odwróconym hash_mapobiekcie .
size_type	Niepodpisany typ liczb całkowitych, który może reprezentować liczbę elementów w obiekcie hash_map.
value_type	Typ, który udostępnia obiekt funkcji, który może porównać dwa elementy jako klucze sortowania, aby określić ich względną kolejność w obiekcie hash_map.

Funkcje składowe

Funkcja składowa	opis
at	Znajduje element w obiekcie hash_map z określoną wartością klucza.
begin	Zwraca iterator odnoszący się do pierwszego elementu w elemecie hash_map.
cbegin	Zwraca iterator const odnoszący się do pierwszego elementu w obiekcie hash_map.
cend	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie hash_map.
clear	Usuwa wszystkie elementy elementu hash_map.
count	Zwraca liczbę elementów w kluczu hash_map , których klucz pasuje do klucza określonego parametrem.
crbegin	const Zwraca iterator odnoszący się do pierwszego elementu w odwróconym hash_mapobiekcie .
crend	const Zwraca iterator, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie hash_map.
emplace	Wstawia element skonstruowany w miejscu do elementu hash_map.
emplace_hint	Wstawia element skonstruowany w miejscu do hash_mapelementu z wskazówką umieszczania.
empty	Sprawdza, czy element hash_map jest pusty.
end	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie hash_map.
equal_range	Zwraca parę iteratorów, odpowiednio, do pierwszego elementu w hash_map obiekcie z kluczem większym niż określony klucz i do pierwszego elementu w hash_map obiekcie z kluczem, który jest równy lub większy niż klucz.
erase	Usuwa element lub zakres elementów z hash_map określonych pozycji
find	Zwraca iterator odnoszący się do lokalizacji elementu w obiekcie hash_map , który ma klucz odpowiadający określonemu kluczowi.
get_allocator	Zwraca kopię obiektu używanego allocator do konstruowania obiektu hash_map.
insert	Wstawia element lub zakres elementów do elementu hash_map.
key_comp	Zwraca iterator do pierwszego elementu w obiekcie hash_map z wartością klucza, która jest równa lub większa od określonego klucza.
lower_bound	Zwraca iterator do pierwszego elementu w obiekcie hash_map z wartością klucza, która jest równa lub większa od określonego klucza.
max_size	Zwraca maksymalną długość obiektu hash_map.
rbegin	Zwraca iterator odnoszący się do pierwszego elementu w odwróconym hash_mapobiekcie .
rend	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie hash_map.
size	Zwraca liczbę elementów w elem.hash_map
swap	Wymienia elementy dwóch hash_maps.
upper_bound	Zwraca iterator do pierwszego elementu w obiekcie hash_map z wartością klucza większą niż określony klucz.
value_comp	Pobiera kopię obiektu porównania używanego do porządkowenia wartości elementów w obiekcie hash_map.

Operatory

Operator	opis
operator[]	Wstawia element do elementu hash_map z określoną wartością klucza.
hash_map::operator=	Zastępuje elementy elementu hash_map kopią innego hash_mapelementu .

Wymagania

Nagłówek: <hash_map>

Przestrzeń nazw: stdext

hash_map::allocator_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Typ reprezentujący klasę alokatora dla obiektu hash_map.

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

Przykład

Zobacz przykład, aby get_allocator zapoznać się z przykładem przy użyciu polecenia allocator_type.

hash_map::at

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Znajduje element w obiekcie hash_map z określoną wartością klucza.

Type& at(const Key& key);

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

Parametry

key
Wartość klucza elementu, który ma zostać znaleziony.

Wartość zwracana

Odwołanie do wartości danych znalezionego elementu.

Uwagi

Jeśli wartość klucza argumentu nie zostanie znaleziona, funkcja zgłasza obiekt klasy out_of_range Class.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca iterator odnoszący się do pierwszego elementu w elemecie hash_map.

const_iterator begin() const;

iterator begin();

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu w hash_map lokalizacji lub kończy się powodzeniem pustego hash_mapelementu .

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca iterator const odnoszący się do pierwszego elementu w obiekcie hash_map.

const_iterator cbegin() const;

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu w hash_map lokalizacji lub, który zakończył się powodzeniem pustego hash_mapelementu .

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

const_iterator cend() const;

Wartość zwracana

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

Uwagi

cend służy do testowania, czy iterator osiągnął koniec jego hash_map.

Wartość zwracana przez cend nie powinna być wyłuszczone.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Usuwa wszystkie elementy elementu hash_map.

void clear();

Uwagi

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej hash_map::clear .

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Uwagi

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

Zdefiniowany const_iterator przez hash_map wskazuje elementy, które są obiektami value_type, czyli typu pair< const Key, Type >, którego pierwszy element członkowski jest kluczem do elementu i którego drugi element członkowski jest mapowanym datą przechowywaną przez element.

Aby wyłuszczyć const_iterator cIter element w elemencie hash_map, użyj -> operatora .

Aby uzyskać dostęp do wartości klucza dla elementu, użyj elementu cIter->first, który jest odpowiednikiem (*cIter).first. Aby uzyskać dostęp do wartości mapowanej datum dla elementu, użyj elementu cIter->second, który jest odpowiednikiem (*cIter).second.

Przykład

Zobacz przykład, aby begin zapoznać się z przykładem przy użyciu polecenia const_iterator.

hash_map::const_pointer

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Uwagi

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

W większości przypadków iterator element powinien być używany do uzyskiwania hash_map dostępu do elementów w obiekcie.

hash_map::const_reference

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Typ, który zawiera odwołanie do elementu przechowywanego const w hash_map obiekcie do odczytu i wykonywania const operacji.

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

Uwagi

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Uwagi

Typ const_reverse_iterator nie może modyfikować wartości elementu i jest używany do iterowania w odwrotnej hash_map części.

Zdefiniowany const_reverse_iterator przez hash_map wskazuje elementy, które są obiektami value_type, czyli typu pair< const Key, Type >, którego pierwszy element członkowski jest kluczem do elementu i którego drugi element członkowski jest mapowanym datą przechowywaną przez element.

Aby wyłuszczyć const_reverse_iterator crIter element w elemencie hash_map, użyj -> operatora .

Aby uzyskać dostęp do wartości klucza dla elementu, użyj elementu crIter->first, który jest odpowiednikiem (*crIter).first. Aby uzyskać dostęp do wartości mapowanej datum dla elementu, użyj elementu crIter->second, który jest odpowiednikiem (*crIter).first.

Przykład

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

hash_map::count

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

size_type count(const Key& key) const;

Parametry

key
Wartość klucza elementów, które mają być dopasowane z elementu hash_map.

Wartość zwracana

1 jeśli hash_map element zawiera element, którego klucz sortowania pasuje do klucza parametru; 0, jeśli hash_map element nie zawiera elementu z pasującym kluczem.

Uwagi

Funkcja składowa zwraca liczbę elementów x w zakresie

lower_bound(key), upper_bound(key)

czyli 0 lub 1 w przypadku hash_map, który jest unikatowym kontenerem asocjacyjnym.

Przykład

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

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

const Zwraca iterator odnoszący się do pierwszego elementu w odwróconym hash_mapobiekcie .

const_reverse_iterator crbegin() const;

Wartość zwracana

Odwrotny const iterator dwukierunkowy odnoszący się do pierwszego elementu w odwróconym hash_map lub odnoszącym się do tego, co było ostatnim elementem w niewróceniu hash_map.

Uwagi

crbegin jest używany z odwróconym hash_map elementem, tak jak begin jest używany z elementem hash_map.

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

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

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

const Zwraca iterator, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie hash_map.

const_reverse_iterator crend() const;

Wartość zwracana

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

Uwagi

crend jest używany z odwróconym hash_map elementem, tak jak hash_map::end jest używany z elementem hash_map.

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

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

Wartość zwracana przez crend nie powinna być wyłuszczone.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Wstawia element skonstruowany w miejscu do elementu hash_map.

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

Parametry

val
Wartość używana do przenoszenia konstrukcji elementu, który ma zostać wstawiony do hash_map elementu , chyba że hash_map już zawiera ten element (lub, ogólnie rzecz biorąc, element, którego klucz jest równoważnie uporządkowany).

Wartość zwracana

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

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

Uwagi

Element hash_map::value_type jest parą, dzięki czemu wartość elementu będzie uporządkowaną parą z pierwszym składnikiem równym wartości klucza i drugiemu składnikowi równemu wartości danych elementu.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Wstawia element skonstruowany w miejscu do hash_mapelementu z wskazówką umieszczania.

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

Parametry

val
Wartość używana do przenoszenia konstrukcji elementu, który ma zostać wstawiony do hash_map elementu , chyba że hash_map już zawiera ten element (lub, ogólnie rzecz biorąc, element, którego klucz jest równoważnie uporządkowany).

c
Wskazówka dotycząca miejsca, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania.

Wartość zwracana

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

Uwagi

Element hash_map::value_type jest parą, dzięki czemu wartość elementu będzie uporządkowaną parą z pierwszym składnikiem równym wartości klucza i drugiemu składnikowi równemu wartości danych elementu.

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

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Sprawdza, czy element hash_map jest pusty.

bool empty() const;

Wartość zwracana

true jeśli wartość jest pusta hash_map ; false jeśli wartość jest pusta hash_map .

Uwagi

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

const_iterator end() const;

iterator end();

Wartość zwracana

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

Uwagi

end służy do testowania, czy iterator osiągnął koniec jego hash_map.

Wartość zwracana przez end nie powinna być wyłuszczone.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca parę iteratorów odpowiednio do pierwszego elementu w hash_map obiekcie z kluczem większym niż określony klucz i do pierwszego elementu w hash_map obiekcie z kluczem równym lub większym niż klucz.

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

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

Parametry

key
Wartość klucza argumentu do porównania z kluczem sortowania elementu z przeszukiwanego hash_map elementu.

Wartość zwracana

Para iteratorów tak, że pierwszy jest lower_bound kluczem, a drugi jest upper_bound kluczem.

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

Uwagi

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parametry

_Where
Pozycja elementu, który ma zostać usunięty z elementu hash_map.

first
Pozycja pierwszego elementu usuniętego z elementu hash_map.

last
Pozycja tuż poza ostatnim elementem usuniętym z elementu hash_map.

key
Wartość klucza elementów, które mają zostać usunięte z elementu hash_map.

Wartość zwracana

W przypadku pierwszych dwóch funkcji składowych iterator dwukierunkowy, który wyznacza pierwszy element pozostający poza usuniętymi elementami lub wskaźnik na końcu hash_map elementu , jeśli taki element nie istnieje.

W przypadku trzeciej funkcji składowej zwraca liczbę elementów, które zostały usunięte z klasy hash_map.

Uwagi

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

Przykład

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

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca iterator odnoszący się do lokalizacji elementu w obiekcie hash_map , który ma klucz odpowiadający określonemu kluczowi.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Wartość klucza, która ma być dopasowywana przez klucz sortowania elementu z przeszukiwanego hash_map elementu.

Wartość zwracana

Iterator, który adresuje lokalizację elementu z określonym kluczem, lub lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_map elemecie , jeśli nie zostanie znalezione dopasowanie klucza.

Uwagi

find Zwraca iterator, który adresuje element w kluczu hash_map sortowania, którego klucz sortowania jest odpowiednikiem klucza argumentu w predykacie binarnym, który wywołuje kolejność na podstawie relacji mniejszej niż porównywalność.

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

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

Allocator get_allocator() const;

Wartość zwracana

Alokator używany przez element hash_map.

Uwagi

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

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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
Klasa alokatora magazynu, która ma być używana dla tego hash_map obiektu, który domyślnie ma wartość Allocator.

Comp
Funkcja porównania typu const Traits używana do porządkowenia elementów w obiekcie hash_map, która domyślnie ma wartość hash_compare.

Right
Z hash_map których skonstruowana mapa ma być kopią.

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

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

IList
initializer_list

Uwagi

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

Wszystkie konstruktory inicjują ich hash_map.

Wszystkie konstruktory przechowują obiekt funkcji typu Traits , który jest używany do ustanowienia kolejności między kluczami elementu hash_map i które można później zwrócić przez wywołanie metody key_comp.

Pierwsze trzy konstruktory określają pusty początkowy , hash_mapa drugi określa typ funkcji porównania (Comp) do użycia w ustaleniu kolejności elementów, a trzeci jawnie określa typ alokatora (Al). Słowo kluczowe explicit pomija niektóre rodzaje automatycznej konwersji typów.

Czwarty konstruktor określa kopię elementu hash_map Right.

Następne trzy konstruktory kopiują zakres [First, Last) z hash_map rosnącą jawnością w określaniu typu funkcji porównania klasy Traits i alokatora.

Ostatni konstruktor przenosi hash_map Rightelement .

hash_map::insert

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Wstawia element lub zakres elementów do elementu 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
Wartość elementu, który ma zostać wstawiony do hash_map elementu , chyba że hash_map zawiera już ten element (lub, ogólniej, element, którego klucz jest odpowiednio uporządkowany).

_Where
Wskazówka dotycząca miejsca, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania.

first
Pozycja pierwszego elementu, który ma zostać skopiowany z elementu hash_map.

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

Wartość zwracana

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

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

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

Ostatnie dwie insert funkcje składowe zachowują się tak samo jak pierwsze dwa, z tą różnicą, że przenoszą one konstrukcję wstawionej wartości.

Uwagi

Element value_type jest parą, dzięki czemu wartość elementu będzie uporządkowaną parą z pierwszym składnikiem równym wartości klucza i drugiemu składnikowi równemu wartości danych elementu.

Wstawianie może wystąpić w amortyzowanym stałym czasie dla wersji wstawiania wskazówek, zamiast czasu logarytmicznych, jeśli punkt wstawiania natychmiast następuje ._Where

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

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Uwagi

Zdefiniowany iterator przez hash_map wskazuje elementy, które są obiektami value_type, czyli typu pair<const Key, Type>, którego pierwszy element członkowski jest kluczem do elementu i którego drugi element członkowski jest mapowanym datą przechowywaną przez element.

Aby wyłudić iterator o nazwie Iter wskazujący element na mapie wielomapowej, użyj -> operatora .

Aby uzyskać dostęp do wartości klucza dla elementu, użyj elementu Iter->first, który jest odpowiednikiem (*Iter).first. Aby uzyskać dostęp do wartości mapowanej datum dla elementu, użyj elementu Iter->second, który jest odpowiednikiem (*Iter).second.

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

Przykład

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

hash_map::key_comp

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Pobiera kopię obiektu porównania używanego do zamawiania kluczy w obiekcie hash_map.

key_compare key_comp() const;

Wartość zwracana

Zwraca obiekt funkcji używany hash_map do porządkowania jego elementów.

Uwagi

Przechowywany obiekt definiuje funkcję składową

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

funkcja ta zwraca wartość true , jeśli left poprzedza wartość i nie jest równa right w kolejności sortowania.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

typedef Traits key_compare;

Uwagi

key_compare jest synonimem parametru Traitsszablonu .

Aby uzyskać więcej informacji na Traits temat tematu hash_map Klasa .

Przykład

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

hash_map::key_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Typ opisuje obiekt klucza sortowania, który stanowi każdy element obiektu hash_map.

typedef Key key_type;

Uwagi

key_type jest synonimem parametru Keyszablonu .

Aby uzyskać więcej informacji na temat Key, zobacz sekcję hash_map Uwagi w temacie Klasa .

Przykład

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

hash_map::lower_bound

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca iterator do pierwszego elementu w obiekcie hash_map z wartością klucza, która jest równa lub większa od określonego klucza.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametry

key
Wartość klucza argumentu do porównania z kluczem sortowania elementu z przeszukiwanego hash_map elementu.

Wartość zwracana

Element iterator lub const_iterator adresujący lokalizację elementu w hash_map obiekcie z kluczem równym lub większym niż klucz argumentu albo adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w obiekcie , hash_map jeśli nie znaleziono dopasowania klucza.

Jeśli zwracana wartość lower_bound elementu jest przypisana do const_iteratorobiektu , hash_map nie można zmodyfikować obiektu. Jeśli wartość zwracana lower_bound obiektu jest przypisana do iteratorobiektu , hash_map można go zmodyfikować.

Uwagi

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Typ reprezentujący typ danych przechowywany w obiekcie hash_map.

typedef Type mapped_type;

Uwagi

Typ mapped_type jest synonimem parametru Typeszablonu .

Aby uzyskać więcej informacji na Type temat tematu hash_map Klasa .

Przykład

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

hash_map::max_size

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca maksymalną długość obiektu hash_map.

size_type max_size() const;

Wartość zwracana

Maksymalna możliwa długość obiektu hash_map.

Uwagi

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Wstawia element do elementu hash_map z określoną wartością klucza.

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

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

Parametry

key
Wartość klucza elementu, który ma zostać wstawiony.

Wartość zwracana

Odwołanie do wartości danych wstawionego elementu.

Uwagi

Jeśli wartość klucza argumentu nie zostanie znaleziona, zostanie wstawiona wraz z wartością domyślną typu danych.

operator[] może służyć do wstawiania elementów do hash_map m elementu using

m[ key] = DataValue;

gdzie DataValue jest wartością mapped_type elementu z wartością keyklucza .

W przypadku użycia operator[] funkcji wstawiania elementów zwrócone odwołanie nie wskazuje, czy wstawienie zmienia wstępnie istniejący element, czy tworzy nowy. Funkcje find składowe i insert mogą służyć do określenia, czy element z określonym kluczem jest już obecny przed wstawieniem.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zastępuje elementy elementu hash_map kopią innego hash_mapelementu .

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

Parametry

right
Klasa right jest kopiowana do klasy hash_map.

Uwagi

Po wymazaniu wszystkich istniejących elementów w obiekcie hash_mapoperator= element kopiuje lub przenosi zawartość right do elementu hash_map.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Uwagi

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

W większości przypadków iterator element powinien być używany do uzyskiwania hash_map dostępu do elementów w obiekcie.

hash_map::rbegin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca iterator odnoszący się do pierwszego elementu w odwróconym hash_mapobiekcie .

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu w odwróconym hash_map lub odnoszącym się do tego, co było ostatnim elementem w niewróceniu hash_map.

Uwagi

rbegin jest używany z odwróconym hash_map elementem, tak jak begin jest używany z elementem hash_map.

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

rbegin może służyć do iterowania przez hash_map tyły.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Uwagi

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Wartość zwracana

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

Uwagi

rend jest używany z odwróconym hash_map elementem, tak jak end jest używany z elementem hash_map.

Jeśli zwracana wartość rend elementu jest przypisana do const_reverse_iteratorobiektu , hash_map nie można zmodyfikować obiektu. Jeśli zwracana wartość rend elementu jest przypisana do reverse_iteratorobiektu , hash_map można go zmodyfikować.

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

Wartość zwracana przez rend nie powinna być wyłuszczone.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Uwagi

Typ reverse_iterator nie może modyfikować wartości elementu i jest używany do iterowania w odwrotnej hash_map części.

Zdefiniowany reverse_iterator przez hash_map wskazuje elementy, które są obiektami value_type, czyli typu pair<const Key, Type>, którego pierwszy element członkowski jest kluczem do elementu i którego drugi element członkowski jest mapowanym datą przechowywaną przez element.

Aby wyłuszczyć reverse_iterator rIter element w elemencie hash_map, użyj -> operatora .

Aby uzyskać dostęp do wartości klucza dla elementu, użyj elementu rIter->first, który jest odpowiednikiem (*rIter).first. Aby uzyskać dostęp do wartości mapowanej datum dla elementu, użyj elementu rIter->second, który jest odpowiednikiem (*rIter).first.

Przykład

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

hash_map::size

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca liczbę elementów w elem.hash_map

size_type size() const;

Wartość zwracana

Bieżąca długość obiektu hash_map.

Uwagi

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej hash_map::size .

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

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

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

Uwagi

Przykład

Zobacz przykład, aby size zapoznać się z przykładem deklarowania i używania size_type

hash_map::swap

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Wymienia elementy dwóch hash_maps.

void swap(hash_map& right);

Parametry

right
Argument hash_map dostarczający elementy, które mają zostać zamienione na element docelowy hash_map.

Uwagi

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

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca iterator do pierwszego elementu w obiekcie hash_map z kluczem o wartości większej niż określony klucz.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametry

key
Wartość klucza argumentu do porównania z wartością klucza sortowania elementu z przeszukiwanego hash_map elementu.

Wartość zwracana

Obiekt iterator lub const_iterator adresujący lokalizację elementu w hash_map obiekcie z kluczem większym niż klucz argumentu lub adresujący lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_map elemecie , jeśli nie zostanie znalezione dopasowanie klucza.

Jeśli wartość zwracana jest przypisana do const_iteratorobiektu , hash_map nie można zmodyfikować obiektu. Jeśli wartość zwracana jest przypisana do iteratorobiektu , hash_map można go zmodyfikować.

Uwagi

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Zwraca obiekt funkcji, który określa kolejność elementów w obiekcie hash_map , porównując ich wartości klucza.

value_compare value_comp() const;

Wartość zwracana

Zwraca obiekt funkcji porównania używany hash_map do porządkowania jego elementów.

Uwagi

W przypadku hash_map melementu , jeśli dwa elementy e1 (k1, d1) i e2 (k2, d2) są obiektami typu , gdzie k1 i k2 są ich kluczami typu key_type value_typei d1 d2 są ich danymi typu mapped_type, jest m.value_comp()(e1, e2) odpowiednikiem m.key_comp()(k1, k2). Przechowywany obiekt definiuje funkcję składową

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

wartość , która zwraca true wartość klucza poprzedniego left i nie jest równa wartości right klucza w kolejności sortowania.

Przykład

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

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest unordered_map Klasa.

Typ reprezentujący typ obiektu przechowywanego w obiekcie hash_map.

typedef pair<const Key, Type> value_type;

Uwagi

value_type jest deklarowany pair<const key_type, mapped_type> jako i nie pair<key_type, mapped_type> dlatego, że klucze kontenera asocjacji nie mogą być zmieniane przy użyciu niekonsektantego iteratora lub odwołania.

Przykład

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

Zobacz też

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