hash_multimap — Klasa

Artykuł
10/12/2023

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Klasa kontenera hash_multimap jest rozszerzeniem standardowej biblioteki C++ i służy do przechowywania i szybkiego pobierania danych z kolekcji, w której każdy element jest parą, która ma klucz sortowania, którego wartość nie musi być 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_multimap

Parametry

Klawisz
Typ danych klucza, który ma być przechowywany w hash_multimap.

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

Cechy
Typ, który zawiera dwa obiekty funkcji, jedną z cech klasy, która jest w stanie 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 kluczowych wartości 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ą.

Programu przydzielania
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące alokacji hash_multimap i cofnięcia alokacji pamięci. Ten argument jest opcjonalny, a wartość domyślna to allocator<pair <const Key, Type>>.

Uwagi

Hash_multimap 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.
Wielokrotna, ponieważ jej elementy nie muszą mieć unikatowych kluczy, więc jedna wartość klucza może mieć wiele wartości elementów danych z nią skojarzonych.
Kontener asocjacyjny pary, ponieważ jego wartości elementów 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 hash_multimap, 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).

Hash_multimap powinien być wybranym kontenerem asocjacyjnym, gdy warunki kojarzenia wartości z kluczami są spełnione przez aplikację. Modelem dla tego typu struktury jest uporządkowana lista słów kluczowych ze skojarzonymi wartościami ciągów, dostarczająca np. definicje, w których słowa nie były zawsze zdefiniowane unikalnie. Jeśli zamiast tego słowa kluczowe zostały unikatowo zdefiniowane tak, aby klucze były unikatowe, hash_map byłby wybranym kontenerem. Jeśli z drugiej strony tylko lista wyrazów była przechowywana, hash_set będzie poprawnym kontenerem. Jeśli dozwolone było wiele wystąpień wyrazów, hash_multiset byłaby odpowiednią strukturą kontenera.

Hash_multimap porządkuje sekwencję, którą kontroluje, wywołując przechowywany obiekt skrótu Traits typu value_compare. Dostęp do tego przechowywanego obiektu można uzyskać, wywołując funkcję składową key_comp. 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 wywołanie Traits (Key) daje rozkład wartości typu size_tKey.

Ogólnie rzecz biorąc, elementy muszą być nieco mniej porównywalne, aby ustalić kolejność: tak aby, mając dowolne dwa elementy, można było określić, czy są one równoważne (w sensie, żaden nie jest mniejszy niż ten drugi) lub, że jeden jest mniejszy niż ten drugi. Powoduje to kolejność między elementami, które nie są równoważne. 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 hash_multimap to ścisłe słabe porządkowanie, jeśli predykat binarny jest nieelastycznym, antysymetrycznym i przechodnim, 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) to 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 dostarczony przez klasę hash_multimap jest iteratorem dwukierunkowym, ale funkcje składowe klasy wstawiają i hash_multimap 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żda koncepcja iteratora ma własne hash_multimap wymagań, a algorytmy, które z nimi współpracują, muszą ograniczyć swoje założenia do wymagań dostarczonych przez ten typ iteratora. 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 minimalna hash_multimap funkcjonalności, ale wystarczy, aby móc mówić znacząco o zakresie iteratorów [First, Last) w kontekście funkcji składowych.

Konstruktory

Konstruktor	opis
hash_multimap	Tworzy listę określonego rozmiaru lub z elementami określonej wartości lub z określoną `allocator` lub kopią innej `hash_multimap`wartości .

Typedefs

Nazwa typu	opis
allocator_type	Typ reprezentujący klasę `allocator` `hash_multimap` dla obiektu.
const_iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytać `const` element w obiekcie `hash_multimap`.
const_pointer	Typ, który dostarcza wskaźnik do `const` elementu w obiekcie `hash_multimap`.
const_reference	Typ, który zawiera odwołanie do elementu przechowywanego `const` w `hash_multimap` 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_multimap`.
difference_type	Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów `hash_multimap` w zakresie między elementami wskazywanym przez iteratory.
Sterująca	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować dowolny element w obiekcie `hash_multimap`.
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_multimap`.
key_type	Typ opisujący obiekt klucza sortowania, który stanowi każdy element obiektu `hash_multimap`.
mapped_type	Typ reprezentujący typ danych przechowywany w obiekcie `hash_multimap`.
wskaźnik	Typ, który dostarcza wskaźnik do elementu w elemecie `hash_multimap`.
odniesienie	Typ, który zawiera odwołanie do elementu przechowywanego w obiekcie `hash_multimap`.
reverse_iterator	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować element w odwróconym `hash_multimap`obiekcie .
size_type	Niepodpisany typ liczb całkowitych, który może reprezentować liczbę elementów w obiekcie `hash_multimap`.
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_multimap`.

Funkcje składowe

Funkcja składowa	opis
zaczynać	Zwraca iterator odnoszący się do pierwszego elementu w elemecie `hash_multimap`.
cbegin	Zwraca iterator const odnoszący się do pierwszego elementu w obiekcie `hash_multimap`.
cend	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie `hash_multimap`.
jasny	Usuwa wszystkie elementy elementu `hash_multimap`.
count	Zwraca liczbę elementów w kluczu `hash_multimap` , których klucz pasuje do klucza określonego parametrem.
crbegin	Zwraca iterator const odnoszący się do pierwszego elementu w odwróconym `hash_multimap`obiekcie .
crend	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie `hash_multimap`.
miejsce	Wstawia element skonstruowany w miejscu do elementu `hash_multimap`.
emplace_hint	Wstawia element skonstruowany w miejscu do `hash_multimap`elementu z wskazówką umieszczania.
empty	Sprawdza, czy element `hash_multimap` jest pusty.
koniec	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie `hash_multimap`.
equal_range	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie `hash_multimap`.
wymazać	Usuwa element lub zakres elementów z `hash_multimap` określonych pozycji
find	Zwraca iterator odnoszący się do lokalizacji elementu w obiekcie `hash_multimap` , który ma klucz odpowiadający określonemu kluczowi.
get_allocator	Zwraca kopię obiektu używanego `allocator` do konstruowania obiektu `hash_multimap`.
wstawiać	Wstawia element lub zakres elementów do `hash_multimap` obiektu w określonej pozycji.
key_comp	Pobiera kopię obiektu porównania używanego do zamawiania kluczy w obiekcie `hash_multimap`.
lower_bound	Zwraca iterator do pierwszego elementu w obiekcie `hash_multimap` z wartością klucza, która jest równa lub większa od określonego klucza.
max_size	Zwraca maksymalną długość obiektu `hash_multimap`.
rbegin	Zwraca iterator odnoszący się do pierwszego elementu w odwróconym `hash_multimap`obiekcie .
drzeć	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie `hash_multimap`.
rozmiar	Określa nowy rozmiar elementu `hash_multimap`.
zamiana	Wymienia elementy dwóch `hash_multimap`s.
upper_bound	Zwraca iterator do pierwszego elementu w obiekcie `hash_multimap` 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_multimap`.

Operatory

Operator	opis
hash_multimap::operator=	Zastępuje elementy elementu `hash_multimap` kopią innego `hash_multimap`elementu .

Wymagania

Nagłówek:<hash_map>

Przestrzeń nazw: stdext

hash_multimap::allocator_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Typ reprezentujący klasę alokatora dla obiektu hash_multimap.

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

Uwagi

allocator_type jest synonimem parametru Allocatorszablonu .

Aby uzyskać więcej informacji na temat Allocatorprogramu , zobacz sekcję Uwagi w temacie hash_multimap Class (Klasa hash_multimap).

Przykład

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

hash_multimap::begin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

const_iterator begin() const;

iterator begin();

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu w hash_multimap lub lokalizacji, która kończy się powodzeniem pustej hash_multimap.

Uwagi

Jeśli zwracana wartość begin elementu jest przypisana do const_iteratorobiektu , nie można modyfikować elementów w obiekcie hash_multimap. Jeśli wartość zwracana begin elementu jest przypisana do iteratorobiektu , elementy w obiekcie hash_multimap można modyfikować.

Przykład

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

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

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

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

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

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

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

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

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

hash_multimap::cbegin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

const_iterator cbegin() const;

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu w hash_multimap lub lokalizacji, która zakończyła się powodzeniem pustego hash_multimapelementu .

Przykład

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

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

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

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

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

The first element of hm1 is 2.

hash_multimap::cend

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

const_iterator cend() const;

Wartość zwracana

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

Uwagi

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

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

Przykład

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

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

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

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

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

The value of last element of hm1 is 30.

hash_multimap::clear

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Usuwa wszystkie elementy hash_multimap.

void clear();

Uwagi

Przykład

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

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

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

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

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

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

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

hash_multimap::const_iterator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

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_multimap wskazuje obiekty value_type, które są typu pair<const Key, Type>. Wartość klucza jest dostępna za pośrednictwem pierwszej pary składowej, a wartość zamapowanego elementu jest dostępna za pośrednictwem drugiego elementu członkowskiego pary.

Aby wyłudić const_iterator cIter element w hash_multimap, 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 zapoznać się z przykładem przy użyciu polecenia const_iterator.

hash_multimap::const_pointer

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

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 powinien być używany do uzyskiwania dostępu do elementów w obiekcie hash_multimap.

hash_multimap::const_reference

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Typ, który zawiera odwołanie do elementu przechowywanego const w hash_multimap do odczytywania i wykonywania const operacji.

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

Uwagi

Przykład

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

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

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

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

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

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

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

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

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

hash_multimap::const_reverse_iterator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

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

Uwagi

Typ const_reverse_iterator nie może zmodyfikować wartości elementu i jest używany do iterowania przez hash_multimap odwrotnie.

Zdefiniowany const_reverse_iterator przez hash_multimap wskazuje obiekty value_type, które są 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ć const_reverse_iterator crIter element w hash_multimap, 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).second.

Przykład

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

hash_multimap::count

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

size_type count(const Key& key) const;

Parametry

key
Klucz elementów do dopasowania z hash_multimap.

Wartość zwracana

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

Uwagi

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

[lower_bound ( key ), upper_bound ( key ) )

które mają klucz wartości klucza.

Przykład

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

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

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

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

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

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

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

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

hash_multimap::crbegin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zwraca iterator const odnoszący się do pierwszego elementu w odwróconej hash_multimap.

const_reverse_iterator crbegin() const;

Wartość zwracana

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

Uwagi

crbeginjest używany z odwróconym hash_multimap tak samo jak hash_multimap::begin jest używany z .hash_multimap

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

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

Przykład

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

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

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

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

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

The first element of the reversed hash_multimap hm1 is 3.

hash_multimap::crend

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

const_reverse_iterator crend() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconej hash_multimap (lokalizacja, która poprzedzała pierwszy element w niereversedowanym hash_multimapelemecie ).

Uwagi

crend jest używany z odwróconym hash_multimap tak samo jak hash_multimap::end jest używany z hash_multimap.

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

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

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

Przykład

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

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

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

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

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

The last element of the reversed hash_multimap hm1 is 3.

hash_multimap::d ifference_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

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

Uwagi

Jest difference_type to typ zwracany podczas odejmowania lub przyrostowania przez iteratory kontenera. Element difference_type jest zwykle używany do reprezentowania liczby elementów w zakresie [pierwszy, ostatni) między iteratorami first i last, zawiera element wskazywany przez first i zakres elementów do, ale nie uwzględnia elementu wskazywanego przez last.

Należy pamiętać, że chociaż difference_type jest dostępny dla wszystkich iteratorów spełniających wymagania iteratora wejściowego, który obejmuje klasę iteratorów dwukierunkowych obsługiwanych przez kontenery odwracalne, takie jak zestaw, odejmowanie między iteratorami jest obsługiwane tylko przez iteratory dostępu losowego udostępniane przez kontener dostępu losowego, taki jak wektor.

Przykład

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

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

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

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

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

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

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

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

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

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

hash_multimap::emplace

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Wstawia element skonstruowany w miejscu do hash_multimap.

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

Parametry

Val
Wartość używana do przenoszenia konstrukcji elementu, który ma zostać wstawiony do hash_multimap.

Wartość zwracana

Funkcja emplace składowa zwraca iterator wskazujący położenie, w którym wstawiono nowy element.

Uwagi

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

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

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

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

hash_multimap::emplace_hint

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Wstawia element skonstruowany na miejsce w hash_multimap 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_multimap , chyba że hash_multimap już zawiera ten element (lub, ogólniej, element, którego klucz jest równoważnie uporządkowany).

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

Wartość zwracana

Funkcja składowa hash_multimap::emplace zwraca iterator wskazujący położenie, w którym nowy element został wstawiony do hash_multimapelementu .

Uwagi

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

Przykład

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

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

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

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

hash_multimap::empty

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Sprawdza, czy hash_multimap jest pusta.

bool empty() const;

Wartość zwracana

true jeśli hash_multimap jest pusta; false jeśli hash_multimap jest brak.

Uwagi

Przykład

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

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

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

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

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

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

hash_multimap::end

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

const_iterator end() const;

iterator end();

Wartość zwracana

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

Uwagi

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

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

Przykład

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

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

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

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

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

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

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

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

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

hash_multimap::equal_range

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zwraca parę iteratorów odpowiednio do pierwszego elementu w hash_multimap z kluczem większym niż określony klucz i do pierwszego elementu w hash_multimap 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
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego hash_multimap.

Wartość zwracana

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

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

Uwagi

Przykład

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

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

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

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

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

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

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

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

   p2 = hm1.equal_range( 4 );

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

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

hash_multimap::erase

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Usuwa element lub zakres elementów w hash_multimap z 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

_Gdzie
Położenie elementu do usunięcia z hash_multimap.

pierwszy
Pozycja pierwszego elementu usunięta z hash_multimap.

ostatni
Pozycja tuż poza ostatnim elementem usuniętym z hash_multimap.

key
Klucz elementów do usunięcia z hash_multimap.

Wartość zwracana

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

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

Uwagi

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

Przykład

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hash_multimap::find

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Klucz do dopasowania według klucza sortowania elementu z przeszukiwanego hash_multimap.

Wartość zwracana

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

Uwagi

Funkcja składowa zwraca iterator, który adresuje element w hash_multimap, którego kluczem sortowania jest equivalent klucz argumentu w predykacie binarnym, który wywołuje kolejność na podstawie relacji mniejszej niż porównywalność.

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

Przykład

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

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

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

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

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

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

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

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

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

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

hash_multimap::get_allocator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

Allocator get_allocator() const;

Wartość zwracana

Alokator używany przez hash_multimap.

Uwagi

Alokatory dla klasy hash_multimap 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_multimap_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

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

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

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

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

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

   hm4_Alloc = hm4.get_allocator( );

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

hash_multimap::hash_multimap

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Tworzy hash_multimap, który jest pusty lub jest kopią wszystkich lub części innych hash_multimap.

hash_multimap();

explicit hash_multimap(
    const Compare& Comp);

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

hash_multimap(
    const hash_multimap& Right);

hash_multimap(
    hash_multimap&& Right);

hash_multimap(
    initializer_list<Type> IList);

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

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

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

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

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

Parametry

Al
Klasa alokatora magazynu, która ma być używana dla tego obiektu hash_multimap, który domyślnie ma wartość Allocator.

Komp
Funkcja porównania typu const Traits używana do porządkowenia elementów na mapie, która jest domyślnie ustawiona na Traits.

Right
Mapa, której skonstruowany zestaw ma być kopią.

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

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

IList
Initializer_list do skopiowania.

Uwagi

Wszystkie konstruktory przechowują typ obiektu alokatora, który zarządza magazynem pamięci dla hash_multimap i które można później zwrócić przez wywołanie get_allocator. Parametr alokatora jest często pomijany w deklaracjach klas, a makra przetwarzania wstępnego są używane do zastępowania alternatywnych alokatorów.

Wszystkie konstruktory inicjują ich hash_multimap.

Wszystkie konstruktory przechowują obiekt funkcji typu Traits , który służy do ustanawiania kolejności między kluczami hash_multimap, a później może zostać zwrócony przez wywołanie key_comp.

Pierwsze trzy konstruktory określają pustą hash_multimap początkową; drugi określa typ funkcji porównania (Comp), która ma być używana w ustanawianiu kolejności elementów, a trzeci jawnie określa typ alokatora (_Al) do użycia. Słowo kluczowe explicit pomija niektóre rodzaje automatycznej konwersji typów.

Czwarty konstruktor określa kopię hash_multimap Right.

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

Ósmy konstruktor przenosi hash_multimap Right.

Ostatnie trzy konstruktory używają initializer_list.

hash_multimap::insert

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Wstawia element lub zakres elementów do hash_multimap.

iterator insert(
    const value_type& Val);

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

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

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

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

Parametry

Val
Wartość elementu, który ma zostać wstawiony do hash_multimap, chyba że zawiera już ten element, lub ogólniej, chyba że zawiera już element, którego klucz jest równoważnie uporządkowany.

Gdzie
Wskazówka dotycząca tego, gdzie rozpocząć wyszukiwanie poprawnego punktu wstawiania.

Pierwszy
Pozycja pierwszego elementu, który ma zostać skopiowany z mapy.

Ostatni
Pozycja tuż poza ostatnim elementem, który ma zostać skopiowany z mapy.

Wartość zwracana

Pierwsze dwie insert funkcje składowe zwracają iterator wskazujący położenie, w którym wstawiono nowy element.

Trzecia funkcja składowa używa initializer_list do wstawienia elementów.

Czwarta funkcja składowa wstawia sekwencję wartości elementów do mapy odpowiadającej każdemu elementowi adresowanemu przez iterator w zakresie [First, Last) określonego zestawu.

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

Uwagi

Value_type elementu jest parą, więc wartość elementu będzie uporządkowaną parą, w której pierwszy składnik jest równy wartości klucza, a drugi składnik jest równy wartości danych elementu.

Wstawienie może wystąpić w amortyzowanym stałym czasie dla wersji insertwskazówek elementu , zamiast czasu logarytmicznych, jeśli punkt wstawiania natychmiast następuje po instrukcji Where.

hash_multimap::iterator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

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

Uwagi

Zdefiniowany iterator przez hash_multimap wskazuje obiekty value_type, które są 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 , który wskazuje element w hash_multimap, 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).first.

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

Przykład

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

hash_multimap::key_comp

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

key_compare key_comp() const;

Wartość zwracana

Zwraca obiekt funkcji, którego hash_multimap używa do zamawiania jego elementów.

Uwagi

Przechowywany obiekt definiuje funkcję składową

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

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

Przykład

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

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

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

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

hash_multimap::key_compare

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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 w hash_multimap.

typedef Traits key_compare;

Uwagi

key_comparejest synonimem cech parametru szablonu.

Aby uzyskać więcej informacji na temat cech , zobacz temat Hash_multimap Class (Klasa hash_multimap).

Przykład

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

hash_multimap::key_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Typ opisujący obiekt klucza sortowania, który stanowi każdy element hash_multimap.

typedef Key key_type;

Uwagi

key_typejest synonimem klucza parametru szablonu.

Aby uzyskać więcej informacji na temat klucza, zobacz sekcję Uwagi w temacie hash_multimap Class (Klasa hash_multimap).

Przykład

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

hash_multimap::lower_bound

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zwraca iterator do pierwszego elementu w hash_multimap z kluczem równym lub większym niż określony klucz.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametry

key
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego hash_multimap.

Wartość zwracana

Iterator lub const_iterator adresujący lokalizację elementu w hash_multimap za pomocą klucza równego lub większego niż klucz argumentu albo adresujący lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_multimap, jeśli nie zostanie znalezione dopasowanie klucza.

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

Uwagi

Przykład

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

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

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

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

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

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

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

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

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

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

hash_multimap::mapped_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Typ reprezentujący typ danych przechowywany w hash_multimap.

typedef Type mapped_type;

Uwagi

mapped_typejest synonimem typu parametru szablonu.

Aby uzyskać więcej informacji o typie , zobacz temat Klasa hash_multimap.

Przykład

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

hash_multimap::max_size

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zwraca maksymalną długość hash_multimap.

size_type max_size() const;

Wartość zwracana

Maksymalna możliwa długość hash_multimap.

Uwagi

Przykład

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

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

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

hash_multimap::operator=

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zastępuje elementy hash_multimap kopią innego hash_multimap.

hash_multimap& operator=(const hash_multimap& right);

hash_multimap& operator=(hash_multimap&& right);

Parametry

Prawy
Hash_multimap kopiowane do pliku hash_multimap.

Uwagi

Po wymazaniu wszystkich istniejących elementów w obiekcie hash_multimapoperator= , kopiuje lub przenosi zawartość bezpośrednio do obiektu hash_multimap.

Przykład

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

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

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

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

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

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

hash_multimap::p inter

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

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 powinien być używany do uzyskiwania dostępu do elementów w obiekcie hash_multimap.

hash_multimap::rbegin

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zwraca iterator odnoszący się do pierwszego elementu w odwróconej hash_multimap.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu w odwróconej hash_multimap lub odnoszący się do tego, co było ostatnim elementem w niereversedowanym hash_multimap.

Uwagi

rbegin jest używany z odwróconym hash_multimap tak samo jak początek jest używany z hash_multimap.

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

rbegin może służyć do iterowania przez hash_multimap wstecz.

Przykład

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

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

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

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

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

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

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

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

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

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

hash_multimap::reference

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

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

Uwagi

Przykład

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

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

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

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

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

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

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

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

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

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

hash_multimap::rend

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zwraca iterator, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconej hash_multimap.

const_reverse_iterator rend() const;

reverse_iterator rend();

Wartość zwracana

Uwagi

rend jest używany z odwróconym hash_multimap tak samo jak koniec jest używany z hash_multimap.

Jeśli zwracana wartość rend elementu jest przypisana do const_reverse_iterator, nie można zmodyfikować obiektu hash_multimap. Jeśli zwracana wartość rend elementu jest przypisana do reverse_iterator, można zmodyfikować obiekt hash_multimap.

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

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

Przykład

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

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

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

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

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

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

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

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

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

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

hash_multimap::reverse_iterator

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

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

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

Uwagi

Typ reverse_iterator jest używany do iterowania przez hash_multimap odwrotnie.

Zdefiniowany reverse_iterator przez hash_multimap wskazuje obiekty value_type, które są typu pair<const Key, Type.> Wartość klucza jest dostępna za pośrednictwem pierwszej pary składowej, a wartość zamapowanego elementu jest dostępna za pośrednictwem drugiego elementu członkowskiego pary.

Przykład

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

hash_multimap::size

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zwraca liczbę elementów w hash_multimap.

size_type size() const;

Wartość zwracana

Bieżąca długość hash_multimap.

Uwagi

Przykład

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

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

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

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

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

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

hash_multimap::size_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Niepodpisany typ liczby całkowitej, który zlicza liczbę elementów w hash_multimap.

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

Uwagi

Przykład

Zobacz przykład rozmiaru, aby zapoznać się z przykładem sposobu deklarowania i używaniasize_type

hash_multimap::swap

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Wymienia elementy dwóch hash_multimaps.

void swap(hash_multimap& right);

Parametry

Prawy
Hash_multimap dostarczające elementy do wymiany lub hash_multimap, których elementy mają być wymieniane z elementami hash_multimap.

Uwagi

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

Przykład

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

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

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

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

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

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

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

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

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

hash_multimap::upper_bound

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Zwraca iterator do pierwszego elementu w hash_multimap z kluczem większym niż określony klucz.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametry

key
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego hash_multimap.

Wartość zwracana

Iterator lub const_iterator adresujący lokalizację elementu w hash_multimap przy użyciu klucza większego niż klucz argumentu lub adresujący lokalizację, która zakończyła się powodzeniem ostatniego elementu w hash_multimap, jeśli nie znaleziono dopasowania dla klucza.

Jeśli wartość zwracana upper_bound elementu jest przypisana do const_iteratorobiektu , nie można zmodyfikować obiektu hash_multimap. Jeśli wartość zwracana upper_bound elementu jest przypisana do iteratorobiektu , można zmodyfikować obiekt hash_multimap.

Uwagi

Przykład

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

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

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

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

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

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

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

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

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

hash_multimap::value_comp

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Funkcja składowa zwraca obiekt funkcji, który określa kolejność elementów w hash_multimap, porównując ich wartości klucza.

value_compare value_comp() const;

Wartość zwracana

Zwraca obiekt funkcji porównania, którego hash_multimap używa do porządkowania elementów.

Uwagi

W przypadku hash_multimap m, jeśli dwa elementy e1 (k1, d1) i e2(k2, d2) są obiektami typu value_type, gdzie k1 i k2 są kluczami typu key_type i d1 i d2 są ich danymi typu mapped_type, a następnie m.value_comp()(e1, e2) jest 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_multimap_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

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

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

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

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

hash_multimap::value_type

Uwaga

Ten interfejs API jest nieaktualny. Alternatywą jest klasa unordered_multimap.

Typ reprezentujący typ obiektu przechowywanego w hash_multimap.

typedef pair<const Key, Type> value_type;

Uwagi

value_typeparametr jest zadeklarowany jako para const key_type, mapped_type, a> nie para<key_type, mapped_type>, ponieważ klucze kontenera kojarzącego mogą nie zostać zmienione przy użyciu niekonseksantowanego iteratora lub odwołania. <

Przykład

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

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

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

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

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

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

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

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

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

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

The key of first element in the hash_multimap is 1.
The data value of first element in the hash_multimap is 10.
The keys of the mapped elements are: 1 2.
The values of the mapped elements are: 10 20.

Zobacz też

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

Udostępnij za pośrednictwem

hash_multimap — Klasa

Składnia

Parametry

Uwagi

Konstruktory

Typedefs

Funkcje składowe

Operatory

Wymagania

hash_multimap::allocator_type

Uwagi

Przykład

hash_multimap::begin

Wartość zwracana

Uwagi

Przykład

hash_multimap::cbegin

Wartość zwracana

Przykład

hash_multimap::cend

Wartość zwracana

Uwagi

Przykład

hash_multimap::clear

Uwagi

Przykład

hash_multimap::const_iterator

Uwagi

Przykład

hash_multimap::const_pointer

Uwagi

hash_multimap::const_reference

Uwagi

Przykład

hash_multimap::const_reverse_iterator

Uwagi

Przykład

hash_multimap::count

Parametry

Wartość zwracana

Uwagi

Przykład

hash_multimap::crbegin

Wartość zwracana

Uwagi

Przykład

hash_multimap::crend

Wartość zwracana

Uwagi

Przykład

hash_multimap::d ifference_type

Uwagi

Przykład

hash_multimap::emplace

Parametry

Wartość zwracana

Uwagi

Przykład

hash_multimap::emplace_hint

Parametry

Wartość zwracana

Uwagi

Przykład

hash_multimap::empty

Wartość zwracana

Uwagi

Przykład

hash_multimap::end

Wartość zwracana

Uwagi

Przykład

hash_multimap::equal_range

Parametry

Wartość zwracana

Uwagi

Przykład

hash_multimap::erase

Parametry

Wartość zwracana