`multimap` Klasa

Artykuł
10/12/2023

Klasa wielomapowa biblioteki standardowej języka C++ służy do przechowywania i pobierania danych z kolekcji, w której każdy element jest parą zawierającą zarówno wartość danych, jak i klucz sortowania. Wartość klucza nie musi być unikatowa i jest używana do automatycznego zamawiania danych. Wartość elementu w mapie wielokrotnej, ale nie wartość jego skojarzonego klucza, może być 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.

Składnia

template <class Key,
    class Type,
    class Traits=less <Key>,
    class Allocator=allocator <pair  <const Key, Type>>>
class multimap;

Parametry

Key
Typ danych klucza, który ma być przechowywany w mapie wielokrotnej.

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

Traits
Typ, który dostarcza obiekt funkcji, która może porównać dwie wartości elementów jako klucze sortowania, aby określić ich względną kolejność w mapie wielokrotnej. Predykat less<Key> binarny jest wartością domyślną.

W języku C++14 można włączyć heterogeniczne wyszukiwanie, określając std::less<> predykat lub std::greater<> bez parametrów typu. Aby uzyskać więcej informacji, zobacz Heterogeniczne wyszukiwanie w kontenerach asocjacyjnych

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

Uwagi

Klasa wielomapowa biblioteki standardowej języka C++ 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 dwukierunkowe iteratory do dostępu do jego elementów.
Posortowany, ponieważ jego elementy są uporządkowane według wartości kluczy w kontenerze zgodnie z określoną funkcją porównywania.
Wiele, ponieważ jego elementy nie muszą mieć unikatowego klucza, więc jedna wartość klucza może mieć wiele skojarzonych wartości danych elementów.
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.

Iterator dostarczany przez klasę mapy jest iteratorem dwukierunkowym, ale funkcje insert składowe klasy i 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ż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.

Wybór typu kontenera powinien ogólnie być oparty o typ wyszukiwania i wstawiania wymagany przez aplikację. Kontenery asocjacyjne są zoptymalizowane dla operacji wyszukiwania, wstawiania i usuwania. Funkcje elementów członkowskich, które jawnie obsługują te operacje, są skuteczne, wykonując je w czasie, który jest średnio proporcjonalny do logarytmu liczby elementów w kontenerze. Wstawianie elementów powoduje unieważnienie żadnych iteratorów i usunięcie elementów unieważnia tylko te iteratory, które wskazywały na usunięte elementy.

Element multimap 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 słów kluczowych ze skojarzonymi wartościami ciągów, na przykład definicjami, w których wyrazy nie zawsze były jednoznacznie zdefiniowane. Jeśli zamiast tego słowa kluczowe zostały unikalnie zdefiniowane, tak że klucze są unikalne, wybranym kontenerem będzie map. Jeśli z drugiej strony, przechowywana była tylko lista wyrazów, poprawnym kontenerem będzie set. Jeśli dozwolone jest wiele wystąpień wyrazów, odpowiednia multiset struktura kontenera będzie odpowiednia.

Kolejność multimap steruje sekwencją przez wywołanie przechowywanego obiektu funkcji typu key_compare. Ten przechowywany obiekt jest funkcją porównania, która może być dostępna przez wywołanie funkcji key_compskładowej . 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. 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 f(x,y) binarny jest obiektem funkcji, który ma dwa obiekty argumentów x i y zwracaną wartość true lub false. Kolejność nałożona na zestaw jest ścisłym słabym uporządkowaniem, 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.

Elementy członkowskie

Konstruktory

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

Typedefs

Nazwa typu	opis
`allocator_type`	Typ reprezentujący klasę `allocator` `multimap` dla obiektu.
`const_iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytać `const` element w obiekcie `multimap`.
`const_pointer`	Typ, który dostarcza wskaźnik do `const` elementu w obiekcie `multimap`.
`const_reference`	Typ, który zawiera odwołanie do elementu przechowywanego `const` w `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 `multimap`.
`difference_type`	Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów `multimap` w zakresie między elementami wskazywanym przez iteratory.
`iterator`	Typ, który zapewnia różnicę między dwoma iteratorami odwołującymi się do elementów w ramach tego samego `multimap`elementu .
`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 `multimap`.
`key_type`	Typ opisujący obiekt klucza sortowania, który składa się na każdy element .`multimap`
`mapped_type`	Typ reprezentujący typ danych przechowywany w obiekcie `multimap`.
`pointer`	Typ, który dostarcza wskaźnik do `const` elementu w obiekcie `multimap`.
`reference`	Typ, który zawiera odwołanie do elementu przechowywanego w obiekcie `multimap`.
`reverse_iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać lub modyfikować element w odwróconym `multimap`obiekcie .
`size_type`	Typ niepodpisanej liczby całkowitej, który zapewnia wskaźnik do `const` elementu w elemecie `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 `multimap`.

Funkcje składowe

Funkcja składowa	opis
`begin`	Zwraca iterator odnoszący się do pierwszego elementu w elemecie `multimap`.
`cbegin`	`const` Zwraca iterator odnoszący się do pierwszego elementu w elemecie `multimap`.
`cend`	Zwraca iterator, który adresuje lokalizację `const` , która zakończyła się powodzeniem ostatniego elementu w elemecie `multimap`.
`clear`	Usuwa wszystkie elementy elementu `multimap`.
`contains`^C++20	Sprawdza, czy w elemecie znajduje się element z określonym kluczem `multimap`.
`count`	Zwraca liczbę elementów w kluczu `multimap` , których klucz pasuje do klucza określonego parametrem.
`crbegin`	`const` Zwraca iterator odnoszący się do pierwszego elementu w odwróconym `multimap`obiekcie .
`crend`	`const` Zwraca iterator, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie `multimap`.
`emplace`	Wstawia element skonstruowany w miejscu do elementu `multimap`.
`emplace_hint`	Wstawia element skonstruowany w miejscu do `multimap`elementu z wskazówką umieszczania
`empty`	Sprawdza, czy element `multimap` jest pusty.
`end`	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie `multimap`.
`equal_range`	Wyszukuje zakres elementów, gdzie klucz elementu pasuje do określonej wartości.
`erase`	Usuwa element lub zakres elementów z `multimap` określonych pozycji lub usuwa elementy zgodne z określonym kluczem.
`find`	Zwraca iterator odnoszący się do pierwszej lokalizacji elementu w obiekcie `multimap` , który ma klucz równoważny określonemu kluczowi.
`get_allocator`	Zwraca kopię obiektu używanego `allocator` do konstruowania obiektu `multimap`.
`insert`	Wstawia element lub zakres elementów do elementu `multimap`.
`key_comp`	Pobiera kopię obiektu porównania używanego do zamawiania kluczy w obiekcie `multimap`.
`lower_bound`	Zwraca iterator do pierwszego elementu w obiekcie `multimap` z kluczem równym lub większym niż określony klucz.
`max_size`	Zwraca maksymalną długość obiektu `multimap`.
`rbegin`	Zwraca iterator odnoszący się do pierwszego elementu w odwróconym `multimap`obiekcie .
`rend`	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie `multimap`.
`size`	Zwraca liczbę elementów w elem.`multimap`
`swap`	Wymienia elementy dwóch `multimap`s.
`upper_bound`	Zwraca iterator do pierwszego elementu w obiekcie `multimap` z kluczem większym niż określony klucz.
`value_comp`	Funkcja składowa zwraca obiekt funkcji, który określa kolejność elementów w obiekcie `multimap` , porównując ich wartości klucza.

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

Wymagania

Nagłówek: <map>

Przestrzeń nazw: std

Pary ( klucz, wartość) są przechowywane w multimap postaci obiektów typu pair. Klasa pary wymaga nagłówka <utility>, który jest automatycznie dołączany przez <map>element .

`multimap::allocator_type`

Typ reprezentujący klasę alokatora multimap dla obiektu.

typedef Allocator allocator_type;

Przykład

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

`multimap::begin`

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

const_iterator begin() const;

iterator begin();

Wartość zwracana

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

Przykład

// multimap_begin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: const_iterator m1_cIter;
   typedef pair <int, int> Int_Pair;

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

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

   m1_Iter = m1.begin ( );
   m1.erase ( m1_Iter );

   // The following 2 lines would err as the iterator is const
   // m1_cIter = m1.begin ( );
   // m1.erase ( m1_cIter );

   m1_cIter = m1.begin( );
   cout << "First element of m1 is now " << m1_cIter -> first << endl;
}

The first element of m1 is 0
First element of m1 is now 1

`multimap::cbegin`

const Zwraca iterator, który adresuje pierwszy element w zakresie.

const_iterator cbegin() const;

Wartość zwracana

const Iterator dostępu dwukierunkowego, który wskazuje pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`multimap::cend`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cend() const;

Wartość zwracana

const Iterator dostępu dwukierunkowego, który wskazuje tuż poza końcem zakresu.

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje end() i cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

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

`multimap::clear`

Usuwa wszystkie elementy elementu multimap.

void clear();

Przykład

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

// multimap_clear.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap<int, int> m1;
   multimap<int, int>::size_type i;
   typedef pair<int, int> Int_Pair;

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

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

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

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

`multimap::const_iterator`

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

typedef implementation-defined const_iterator;

Uwagi

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

Zdefiniowany const_iterator przez multimap punkty do obiektów typu 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łuszczyć const_iterator cIter element w elemencie 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 begin zapoznać się z przykładem przy użyciu polecenia const_iterator.

`multimap::const_pointer`

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

typedef typename 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 multimap dostępu do elementów w obiekcie.

`multimap::const_reference`

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

typedef typename allocator_type::const_reference const_reference;

Przykład

// multimap_const_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

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

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

`multimap::const_reverse_iterator`

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

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Uwagi

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

Zdefiniowany const_reverse_iterator przez multimap punkty do obiektów typu 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łuszczyć const_reverse_iterator crIter element w wielomapie, 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 sposobu deklarowania i używania elementu const_reverse_iterator.

`multimap::contains`

Sprawdź, czy w elemecie znajduje się element z określonym kluczem multimap.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Parametry

K
Typ klucza.

key
Wartość klucza elementu do wyszukania.

Wartość zwracana

true jeśli element zostanie znaleziony w kontenerze; false inaczej.

Uwagi

contains() jest nowy w języku C++20. Aby go użyć, określ lub nowszą /std:c++20 opcję kompilatora.

template<class K> bool contains(const K& key) const Uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli key_compare jest przezroczysty. Aby uzyskać więcej informacji, zobacz Heterogeniczne wyszukiwanie w kontenerach asocjacyjnych.

Przykład

// Requires /std:c++20 or /std:c++latest
#include <map>
#include <string>
#include <iostream>
#include <functional>

int main()
{
    std::multimap<int, bool> m = {{0, false}, {1, true}};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << m.contains(1) << '\n';
    std::cout << m.contains(2) << '\n';

    // call template function
    std::multimap<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

`multimap::count`

Zwraca liczbę elementów w kluczu multimap , których klucze są zgodne z kluczem określonym przez parametr.

size_type count(const Key& key) const;

Parametry

key
Klucz elementów do dopasowania z wielomapy.

Wartość zwracana

Liczba elementów, których klucze sortowania są zgodne z kluczem parametru; 0, jeśli multimapa 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ą wartość keyklucza .

Przykład

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

// multimap_count.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
    using namespace std;
    multimap<int, int> m1;
    multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

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

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

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

`multimap::crbegin`

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

const_reverse_iterator crbegin() const;

Wartość zwracana

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

Uwagi

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

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

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

Przykład

// multimap_crbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_crIter = m1.crbegin( );
   cout << "The first element of the reversed multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed multimap m1 is 3.

`multimap::crend`

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

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 multimap (lokalizacja, która poprzedzała pierwszy element w niewróconym multimapelemecie ).

Uwagi

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

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

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

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

Przykład

// multimap_crend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_crIter = m1.crend( );
   m1_crIter--;
   cout << "The last element of the reversed multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed multimap m1 is 1.

`multimap::difference_type`

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

typedef typename 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 [first, last) między iteratorami first i last, zawiera element wskazywany przez first i zakres elementów do, ale nie uwzględnia, element wskazywany przez last.

Mimo difference_type że jest dostępna dla wszystkich iteratorów, które spełniają 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

// multimap_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <map>
#include <algorithm>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

   // The following will insert as multimap keys are not unique
   m1.insert ( Int_Pair ( 2, 30 ) );

   multimap <int, int>::iterator m1_Iter, m1_bIter, m1_eIter;
   m1_bIter = m1.begin( );
   m1_eIter = m1.end( );

   // Count the number of elements in a multimap
   multimap <int, int>::difference_type  df_count = 0;
   m1_Iter = m1.begin( );
   while ( m1_Iter != m1_eIter )
   {
      df_count++;
      m1_Iter++;
   }

   cout << "The number of elements in the multimap m1 is: "
        << df_count << "." << endl;
}

The number of elements in the multimap m1 is: 4.

`multimap::emplace`

Wstawia element skonstruowany na miejscu (nie są wykonywane żadne operacje kopiowania ani przenoszenia).

template <class... Args>
iterator emplace(Args&&... args);

Parametry

args
Argumenty przekazane w celu skonstruowania elementu, który ma zostać wstawiony do elementu multimap.

Wartość zwracana

Iterator nowo wstawiony element.

Uwagi

Żadne odwołania do elementów kontenera nie są unieważniane przez tę funkcję, ale może unieważnić wszystkie iteratory do kontenera.

Jeśli podczas wstawiania zgłaszany jest wyjątek, kontener pozostanie niezauniknięty, a wyjątek zostanie ponownie dodany.

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.

Przykład

// multimap_emplace.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: " << endl;

    for (const auto& p : m) {
        cout << "(" << p.first <<  "," << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    multimap<string, string> m1;

    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

    cout << "multimap modified, now contains ";
    print(m1);
    cout << endl;

    m1.emplace("Bob", "Engineering");

    cout << "multimap modified, now contains ";
    print(m1);
    cout << endl;
}

`multimap::emplace_hint`

Wstawia element skonstruowany na miejscu (nie są wykonywane żadne operacje kopiowania lub przenoszenia) z wskazówką umieszczania.

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Parametry

args
Argumenty przekazane w celu skonstruowania elementu, który ma zostać wstawiony do elementu multimap.

where
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania. (Jeśli ten punkt bezpośrednio poprzedza where, wstawienie może wystąpić w amortyzowanym czasie stałym zamiast czasu logarytmicznych).

Wartość zwracana

Iterator nowo wstawiony element.

Uwagi

Żadne odwołania do elementów kontenera nie są unieważniane przez tę funkcję, ale może unieważnić wszystkie iteratory do kontenera.

W przypadku zgłoszenia wyjątku stan kontenera nie jest modyfikowany podczas zastępowania.

Aby zapoznać się z przykładem kodu, zobacz map::emplace_hint.

`multimap::empty`

Sprawdza, czy element multimap jest pusty.

bool empty() const;

Wartość zwracana

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

Przykład

// multimap_empty.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2;

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

   if ( m1.empty( ) )
      cout << "The multimap m1 is empty." << endl;
   else
      cout << "The multimap m1 is not empty." << endl;

   if ( m2.empty( ) )
      cout << "The multimap m2 is empty." << endl;
   else
      cout << "The multimap m2 is not empty." << endl;
}

The multimap m1 is not empty.
The multimap m2 is empty.

`multimap::end`

Zwraca iterator poza końcem.

const_iterator end() const;

iterator end();

Wartość zwracana

Iterator przeszłości. Jeśli wartość jest pusta multimap , to multimap::end() == multimap::begin().

Uwagi

end służy do testowania, czy iterator przeszedł koniec jego multimap.

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

Aby zapoznać się z przykładem kodu, zobacz multimap::find.

`multimap::equal_range`

Wyszukuje zakres elementów, gdzie klucz elementu pasuje do określonej wartości.

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 multimap przeszukiwanego 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).

Przykład

// multimap_equal_range.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   typedef multimap <int, int, less<int> > IntMMap;
   IntMMap m1;
   multimap <int, int> :: const_iterator m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

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

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

   cout << "The upper bound of the element with "
        << "a key of 2 in the multimap m1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   m1_RcIter = m1.upper_bound( 2 );

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

   p2 = m1.equal_range( 4 );

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

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

`multimap::erase`

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

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametry

Where
Położenie elementu do usunięcia.

First
Pozycja pierwszego elementu do usunięcia.

Last
Pozycja tuż poza ostatnim elementem, który ma zostać usunięty.

Key
Klucz elementów do usunięcia.

Wartość zwracana

W przypadku pierwszych dwóch funkcji składowych iterator dwukierunkowy, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub elementem, który jest końcem mapy, jeśli taki element nie istnieje.

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

Uwagi

Aby zapoznać się z przykładem kodu, zobacz map::erase.

`multimap::find`

Zwraca iterator odwołujący się do pierwszej lokalizacji elementu w obiekcie multimap , 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 multimap elementu.

Wartość zwracana

Iterator odwołujący się do lokalizacji elementu z określonym kluczem lub lokalizacji, która zakończyła się powodzeniem ostatniego elementu w elemecie multimap (multimap::end()), jeśli nie zostanie znalezione dopasowanie klucza.

Uwagi

Funkcja składowa zwraca iterator, który odwołuje się do elementu w kluczu multimap 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 , multimap nie można zmodyfikować obiektu. Jeśli wartość zwracana find elementu jest przypisana do iteratorobiektu , multimap można go zmodyfikować.

Przykład

// compile with: /EHsc /W4 /MTd
#include <map>
#include <iostream>
#include <vector>
#include <string>
#include <utility>  // make_pair()

using namespace std;

template <typename A, typename B> void print_elem(const pair<A, B>& p) {
    cout << "(" << p.first << ", " << p.second << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    multimap<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting multimap m1 is (key, value):" << endl;
    print_collection(m1);

    vector<pair<int, string>> v;
    v.push_back(make_pair(43, "Tc"));
    v.push_back(make_pair(41, "Nb"));
    v.push_back(make_pair(46, "Pd"));
    v.push_back(make_pair(42, "Mo"));
    v.push_back(make_pair(44, "Ru"));
    v.push_back(make_pair(44, "Ru")); // attempt a duplicate

    cout << "Inserting the following vector data into m1:" << endl;
    print_collection(v);

    m1.insert(v.begin(), v.end());

    cout << "The modified multimap m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

`multimap::get_allocator`

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

allocator_type get_allocator() const;

Wartość zwracana

Alokator używany przez element multimap.

Uwagi

Alokatory dla multimap 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

// multimap_get_allocator.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int>::allocator_type m1_Alloc;
   multimap <int, int>::allocator_type m2_Alloc;
   multimap <int, double>::allocator_type m3_Alloc;
   multimap <int, int>::allocator_type m4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   multimap <int, int> m1;
   multimap <int, int, allocator<int> > m2;
   multimap <int, double, allocator<double> > m3;

   m1_Alloc = m1.get_allocator( );
   m2_Alloc = m2.get_allocator( );
   m3_Alloc = m3.get_allocator( );

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

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

   // The following line creates a multimap m4
   // with the allocator of multimap m1.
   map <int, int> m4( less<int>( ), m1_Alloc );

   m4_Alloc = m4.get_allocator( );

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

`multimap::insert`

Wstawia element lub zakres elementów do elementu multimap.

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

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

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Parametry

Val
Wartość elementu, który ma zostać wstawiony do elementu multimap.

Where
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania. (Jeśli ten punkt bezpośrednio poprzedza Where, wstawienie może wystąpić w amortyzowanym czasie stałym zamiast czasu logarytmicznych).

ValTy
Parametr szablonu określający typ argumentu, którego mapa może użyć do skonstruowania elementu value_type, i idealnego do przodu Val jako argumentu.

First
Położenie pierwszego elementu do skopiowania.

Last
Pozycja tuż poza ostatnim elementem do skopiowania.

InputIterator
Argument funkcji szablonu spełniający wymagania input iteratora wskazujące elementy typu, które mogą służyć do konstruowania value_type obiektów.

IList
Element initializer_list , z którego mają być skopiowane elementy.

Wartość zwracana

Funkcje składowe z jednym elementem, (1) i (2) zwracają iterator do pozycji, w której nowy element został wstawiony do multimapelementu .

Funkcje składowe single-element-with-hint( 3) i (4) zwracają iterator wskazujący położenie, w którym nowy element został wstawiony do multimapelementu .

Uwagi

Ta funkcja nie unieważnia wskaźników ani odwołań, ale może unieważnić wszystkie iteratory do kontenera.

Podczas wstawiania tylko jednego elementu, jeśli zgłaszany jest wyjątek, stan kontenera nie jest modyfikowany. Podczas wstawiania wielu elementów, jeśli zostanie zgłoszony wyjątek, kontener pozostanie w nieokreślonym, ale prawidłowym stanie.

Kontener value_type to definicja typu, która należy do kontenera, a dla mapowania multimap<K, V>::value_type to pair<const K, V>. Wartość elementu jest 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.

Funkcja składowa zakresu (5) wstawia sekwencję wartości elementów do multimap elementu odpowiadającego każdemu elementowi adresowanemu przez iterator w zakresie [First, Last); w związku z tym Last nie zostanie wstawiona. Funkcja end() składowa kontenera odwołuje się do pozycji tuż po ostatnim elemencie w kontenerze — na przykład instrukcja m.insert(v.begin(), v.end()); wstawia wszystkie elementy v do melementu .

Funkcja składowa listy inicjatora (6) używa elementu initializer_list do kopiowania elementów do mapy.

W przypadku wstawiania elementu skonstruowanego na miejscu — czyli nie są wykonywane żadne operacje kopiowania lub przenoszenia — zobacz multimap::emplace i multimap::emplace_hint.

Przykład

// multimap_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>
#include <vector>
#include <utility>  // make_pair()

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    multimap<int, int> m1;
    // call insert(const value_type&) version
    m1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    m1.insert(make_pair(2, 20));

    cout << "The original key and mapped values of m1 are:" << endl;
    print(m1);

    // intentionally attempt a duplicate, single element
    m1.insert(make_pair(1, 111));

    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);

    // single element, with hint
    m1.insert(m1.end(), make_pair(3, 30));
    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);
    cout << endl;

    // The templatized version inserting a jumbled range
    multimap<int, int> m2;
    vector<pair<int, int>> v;
    v.push_back(make_pair(43, 294));
    v.push_back(make_pair(41, 262));
    v.push_back(make_pair(45, 330));
    v.push_back(make_pair(42, 277));
    v.push_back(make_pair(44, 311));

    cout << "Inserting the following vector data into m2:" << endl;
    print(v);

    m2.insert(v.begin(), v.end());

    cout << "The modified key and mapped values of m2 are:" << endl;
    print(m2);
    cout << endl;

    // The templatized versions move-constructing elements
    multimap<int, string>  m3;
    pair<int, string> ip1(475, "blue"), ip2(510, "green");

    // single element
    m3.insert(move(ip1));
    cout << "After the first move insertion, m3 contains:" << endl;
    print(m3);

    // single element with hint
    m3.insert(m3.end(), move(ip2));
    cout << "After the second move insertion, m3 contains:" << endl;
    print(m3);
    cout << endl;

    multimap<int, int> m4;
    // Insert the elements from an initializer_list
    m4.insert({ { 4, 44 }, { 2, 22 }, { 3, 33 }, { 1, 11 }, { 5, 55 } });
    cout << "After initializer_list insertion, m4 contains:" << endl;
    print(m4);
    cout << endl;
}

`multimap::iterator`

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

typedef implementation-defined iterator;

Uwagi

Zdefiniowany iterator przez multimap punkty do obiektów typu 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łusić iterator Iter element w elemencie 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).second.

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

Przykład

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

`multimap::key_comp`

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

key_compare key_comp() const;

Wartość zwracana

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

Uwagi

Przechowywany obiekt definiuje funkcję składową

bool operator( const Key& x, const Key& y);

wartość , która zwraca wartość true, jeśli x jest ściśle poprzedzona y kolejnością sortowania.

Przykład

// multimap_key_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

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

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

kc1( 2,3 ) returns value of true, where kc1 is the function object of m1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of m2.

`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 multimap.

typedef Traits key_compare;

Uwagi

key_compare jest synonimem parametru Traitsszablonu .

Aby uzyskać więcej informacji na temat Traitsprogramu , zobacz multimap temat Klasa .

Przykład

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

`multimap::key_type`

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

typedef Key key_type;

Uwagi

key_type jest synonimem parametru Keyszablonu .

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

Przykład

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

`multimap::lower_bound`

Zwraca iterator do pierwszego elementu w obiekcie 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 multimap przeszukiwanego elementu.

Wartość zwracana

Iterator lub const_iterator adresujący lokalizację elementu w multimap 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 , multimap jeśli nie zostanie znalezione dopasowanie klucza.

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

Przykład

// multimap_lower_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   m1_RcIter = m1.lower_bound( 2 );
   cout << "The element of multimap m1 with a key of 2 is: "
        << m1_RcIter -> second << "." << endl;

   m1_RcIter = m1.lower_bound( 3 );
   cout << "The first element of multimap m1 with a key of 3 is: "
        << m1_RcIter -> second << "." << endl;

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

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

   // The element at a specific location in the multimap can be
   // found using a dereferenced iterator addressing the location
   m1_AcIter = m1.end( );
   m1_AcIter--;
   m1_RcIter = m1.lower_bound( m1_AcIter -> first );
   cout << "The first element of m1 with a key matching\n"
        << "that of the last element is: "
        << m1_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 ( m1_RcIter == --m1.end( ) )
      cout << "This is the last element of multimap m1."
           << endl;
   else
      cout << "This is not the last element of multimap m1."
           << endl;
}

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

`multimap::mapped_type`

Typ reprezentujący typ danych przechowywany w obiekcie multimap.

typedef Type mapped_type;

Uwagi

mapped_type jest synonimem parametru Typeszablonu .

Aby uzyskać więcej informacji na temat Typeprogramu , zobacz multimap temat Klasa .

Przykład

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

`multimap::max_size`

Zwraca maksymalną długość obiektu multimap.

size_type max_size() const;

Wartość zwracana

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

Przykład

// multimap_max_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: size_type i;

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

`multimap::multimap`

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

multimap();

explicit multimap(
    const Traits& Comp);

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

map(
    const multimap& Right);

multimap(
    multimap&& Right);

multimap(
    initializer_list<value_type> IList);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

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

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

Parametry

Al
Klasa alokatora magazynu, która ma być używana dla tego obiektu wielomapowego, który jest domyślnie alokatorem.

Comp
Funkcja porównania typu constTraits 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ą.

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
Lista initializer_list, z której mają być skopiowane elementy.

Uwagi

Wszystkie konstruktory przechowują typ obiektu alokatora, który zarządza magazynem pamięci dla multimap obiektu i który 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 multimap.

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

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

Czwarty konstruktor określa kopię elementu multimap Right.

Piąty konstruktor określa kopię obiektu multimap przez przeniesienie prawej.

6, 7 i 8 konstruktorów kopiuje elementy członkowskie elementu initializer_list.

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.

Przykład

// multimap_ctor.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

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

    // Create an empty multimap m0 of key type integer
    multimap <int, int> m0;

    // Create an empty multimap m1 with the key comparison
    // function of less than, then insert 4 elements
    multimap <int, int, less<int> > m1;
    m1.insert(Int_Pair(1, 10));
    m1.insert(Int_Pair(2, 20));
    m1.insert(Int_Pair(3, 30));
    m1.insert(Int_Pair(4, 40));

    // Create an empty multimap m2 with the key comparison
    // function of greater than, then insert 2 elements
    multimap <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

    // Create a multimap m3 with the
    // allocator of multimap m1
    multimap <int, int>::allocator_type m1_Alloc;
    m1_Alloc = m1.get_allocator();
    multimap <int, int> m3(less<int>(), m1_Alloc);
    m3.insert(Int_Pair(3, 30));

    // Create a copy, multimap m4, of multimap m1
    multimap <int, int> m4(m1);

    // Create a multimap m5 by copying the range m1[ first,  last)
    multimap <int, int>::const_iterator m1_bcIter, m1_ecIter;
    m1_bcIter = m1.begin();
    m1_ecIter = m1.begin();
    m1_ecIter++;
    m1_ecIter++;
    multimap <int, int> m5(m1_bcIter, m1_ecIter);

    // Create a multimap m6 by copying the range m4[ first,  last)
    // and with the allocator of multimap m2
    multimap <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    multimap <int, int> m6(m4.begin(), ++m4.begin(), less<int>(), m2_Alloc);

    cout << "m1 =";
    for (auto i : m1)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m2 =";
    for (auto i : m2)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m3 =";
    for (auto i : m3)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m4 =";
    for (auto i : m4)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m5 =";
    for (auto i : m5)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m6 =";
    for (auto i : m6)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m8 by copying in an initializer_list
    multimap<int, int> m8{ { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 } } };
    cout << "m8: = ";
    for (auto i : m8)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m9 with an initializer_list and a comparator
    multimap<int, int> m9({ { 5, 5 }, { 6, 6 }, { 7, 7 }, { 8, 8 } }, less<int>());
    cout << "m9: = ";
    for (auto i : m9)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m10 with an initializer_list, a comparator, and an allocator
    multimap<int, int> m10({ { 9, 9 }, { 10, 10 }, { 11, 11 }, { 12, 12 } }, less<int>(), m9.get_allocator());
    cout << "m10: = ";
    for (auto i : m10)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

}

`multimap::operator=`

Zastępuje elementy elementu multimap kopią innego multimapelementu .

multimap& operator=(const multimap& right);

multimap& operator=(multimap&& right);

Parametry

right
Element multimap kopiowany do pliku multimap.

Uwagi

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

Przykład

// multimap_operator_as.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
   {
   using namespace std;
   multimap<int, int> v1, v2, v3;
   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;
   }

`multimap::pointer`

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

typedef typename 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 multimap dostępu do elementów w obiekcie.

`multimap::rbegin`

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Wartość zwracana

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

Uwagi

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

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

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

Przykład

// multimap_rbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_rIter = m1.rbegin( );
   cout << "The first element of the reversed multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

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

   // A multimap element can be erased by dereferencing its key
   m1_rIter = m1.rbegin( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed multimap is "
        << m1_rIter -> first << "." << endl;
}

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

`multimap::reference`

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

typedef typename allocator_type::reference reference;

Przykład

// multimap_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

   cout << "The data value of first element in the 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 multimap is 1.
The data value of first element in the multimap is 10.
The modified data value of first element is 15.

`multimap::rend`

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

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 multimap (lokalizacja, która poprzedzała pierwszy element w niewróconym multimapelemecie ).

Uwagi

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

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

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

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

Przykład

// multimap_rend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "The last element of the reversed multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

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

   // A multimap element can be erased by dereferencing to its key
   m1_rIter = --m1.rend( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed multimap is "
        << m1_rIter -> first << "." << endl;
}

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

`multimap::reverse_iterator`

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

typedef std::reverse_iterator<iterator> reverse_iterator;

Uwagi

Typ reverse_iterator służy do iterowania w odwrotnej multimap kolejności.

Zdefiniowany reverse_iterator przez multimap punkty do obiektów typu 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łuszczyć reverse_iterator rIter element w elemencie multimap, 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).second.

Przykład

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

`multimap::size`

Zwraca liczbę elementów w elem.multimap

size_type size() const;

Wartość zwracana

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

Przykład

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

// multimap_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    multimap<int, int> m1, m2;
    multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

The multimap length is 1.
The multimap length is now 2.

`multimap::size_type`

Niepodpisany typ liczb całkowitych, który zlicza liczbę elementów w obiekcie multimap.

typedef typename allocator_type::size_type size_type;

Przykład

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

`multimap::swap`

Wymienia elementy dwóch multimaps.

void swap(
    multimap<Key, Type, Traits, Allocator>& right);

Parametry

right
Podanie multimap elementów do zamiany lub multimap elementów, których elementy mają być wymieniane z elementami multimap left.

Uwagi

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

Przykład

// multimap_swap.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2, m3;
   multimap <int, int>::iterator m1_Iter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );
   m2.insert ( Int_Pair ( 10, 100 ) );
   m2.insert ( Int_Pair ( 20, 200 ) );
   m3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   m1.swap( m2 );

   cout << "After swapping with m2, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( m1, m3 );

   cout << "After swapping with m3, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

The original multimap m1 is: 10 20 30.
After swapping with m2, multimap m1 is: 100 200.
After swapping with m3, multimap m1 is: 300.

`multimap::upper_bound`

Zwraca wartość iterator do pierwszego elementu w obiekcie 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 multimap przeszukiwanego elementu.

Wartość zwracana

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

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

Przykład

// multimap_upper_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

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

   m1_RcIter = m1.upper_bound( 2 );
   cout << "The first element of multimap m1 with a key "
        << " greater than 2 is: "
        << m1_RcIter -> second << "." << endl;

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

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

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

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

`multimap::value_comp`

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

value_compare value_comp() const;

Wartość zwracana

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

Uwagi

W przypadku elementu multimap , jeśli dwa elementy e1(k1, d1) i e2(k2, d2) są obiektami typu value_type, gdzie k1 i k2 są ich kluczami typu i d1 d2 są ich danymi typu mapped_typekey_type , jest m.value_comp(e1, e2) to odpowiednik m.key_comp(k1, k2).m

Przykład

// multimap_value_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   multimap<int,int>::iterator Iter1, Iter2;

   Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= m1.insert ( 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;
   }
}

The element ( 1,10 ) precedes the element ( 2,5 ).
The element ( 2,5 ) does not precede the element ( 1,10 ).

`multimap::value_type`

Typ reprezentujący typ obiektu przechowywanego jako element na mapie.

typedef pair<const Key, Type> value_type;

Przykład

// multimap_value_type.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

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

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

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

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

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

   cout << "The data value of first element in the 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 = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

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

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

Zobacz też

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

Udostępnij za pośrednictwem

multimap Klasa

Składnia

Parametry

Uwagi

Elementy członkowskie

Konstruktory

Typedefs

Funkcje składowe

Wymagania

multimap::allocator_type

Przykład

multimap::begin

Wartość zwracana

Przykład

multimap::cbegin

Wartość zwracana

Uwagi

multimap::cend

Wartość zwracana

Uwagi

multimap::clear

Przykład

multimap::const_iterator

Uwagi

Przykład

multimap::const_pointer

Uwagi

multimap::const_reference

Przykład

multimap::const_reverse_iterator

Uwagi

Przykład

multimap::contains

Parametry

Wartość zwracana

Uwagi

Przykład

multimap::count

Parametry

Wartość zwracana

Uwagi

Przykład

multimap::crbegin

Wartość zwracana

Uwagi

Przykład

multimap::crend

Wartość zwracana

Uwagi

Przykład

multimap::difference_type

Uwagi

Przykład

multimap::emplace

Parametry

Wartość zwracana

Uwagi

Przykład

multimap::emplace_hint

Parametry

Wartość zwracana

Uwagi

multimap::empty

Wartość zwracana

Przykład

multimap::end

Wartość zwracana

Uwagi

multimap::equal_range

Parametry

Wartość zwracana

Przykład

multimap::erase

Parametry

Wartość zwracana

Uwagi

multimap::find

Parametry

Wartość zwracana

`multimap` Klasa

`multimap::allocator_type`

`multimap::begin`

`multimap::cbegin`

`multimap::cend`

`multimap::clear`

`multimap::const_iterator`

`multimap::const_pointer`

`multimap::const_reference`

`multimap::const_reverse_iterator`

`multimap::contains`

`multimap::count`

`multimap::crbegin`

`multimap::crend`

`multimap::difference_type`

`multimap::emplace`

`multimap::emplace_hint`

`multimap::empty`

`multimap::end`

`multimap::equal_range`

`multimap::erase`

`multimap::find`

`multimap::get_allocator`

`multimap::insert`

`multimap::iterator`

`multimap::key_comp`

`multimap::key_compare`

`multimap::key_type`

`multimap::lower_bound`

`multimap::mapped_type`

`multimap::max_size`

`multimap::multimap`

`multimap::operator=`

`multimap::pointer`

`multimap::rbegin`

`multimap::reference`

`multimap::rend`

`multimap::reverse_iterator`

`multimap::size`

`multimap::size_type`

`multimap::swap`

`multimap::upper_bound`