`multimap` Třída

Článek
10/12/2023

Multimapová třída standardní knihovny C++ slouží k ukládání a načítání dat z kolekce, ve které je každý prvek dvojicí, která má datovou hodnotu i klíč řazení. Hodnota klíče nemusí být jedinečná a slouží k automatickému seřazení dat. Hodnotu prvku v objektu multimap, ale ne jeho přidruženou hodnotu klíče, lze změnit přímo. Namísto toho hodnoty klíčů přidružené ke starým prvkům musí být odstraněny a vloženy nové hodnoty klíče související s novými prvky.

Syntaxe

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

Parametry

Key
Datový typ klíče, který se uloží v objektu multimap.

Type
Typ dat prvku, který bude uložen do objektu multimap.

Traits
Typ poskytující objekt funkce, který může porovnat dvě hodnoty prvků pro určení jejich relativního pořadí v objektu multimap. Binární predikát less<Key> je výchozí hodnota.

V jazyce C++14 můžete povolit heterogenní vyhledávání zadáním std::less<> nebo std::greater<> predikátu, který neobsahuje parametry typu. Další informace najdete v tématu Heterogenní vyhledávání v asociativních kontejnerech.

Allocator
Typ představující uložený objekt alokátoru, který zapouzdřuje informace o přidělování a navrácení paměti zpět objektu map. Tento argument je nepovinný a výchozí hodnota je allocator<pair <const Key, Type> >.

Poznámky

Multimapová třída standardní knihovny C++ je

Asociativní kontejner, což je kontejner proměnné velikosti, který podporuje efektivní načtení hodnoty prvku založené na přiřazené hodnotě klíče.
Oboustranný, protože poskytuje obousměrné iterátory pro přístup k jeho prvkům.
Seřazený, protože jeho prvky jsou řazeny podle hodnot klíče v kontejneru podle zadané porovnávací funkce.
Násobek, protože jeho prvky nemusí mít jedinečný klíč, takže jedna hodnota klíče může obsahovat mnoho datových hodnot prvků.
Kontejner asociativních párů, protože jeho prvky hodnoty dat se liší od hodnot klíčů.
Šablona třídy, protože funkce, které poskytuje, je obecná a tak nezávislá na konkrétním typu dat obsažených jako prvky nebo klíče. Datové typy použité pro prvky a klíče jsou místo toho zadány jako parametry v šabloně třídy společně s funkcí porovnání a alokátorem.

Iterátor poskytovaný mapovou třídou je obousměrný iterátor, ale členské funkce insert třídy a multimap mají verze, které berou jako parametry šablony slabší vstupní iterátor, jehož požadavky na funkčnost jsou více minimální než ty, které zaručuje třída obousměrných iterátorů. Různé koncepty iterátorů tvoří rodinu týkající se upřesnění jejich funkčnosti. Každý koncept iterátoru má vlastní sadu požadavků a algoritmy, které s nimi pracují, musí omezit jejich předpoklady na požadavky podle typu iterátoru. Lze předpokládat, že ke vstupnímu iterátoru lze přistoupit přes ukazatel pro odkazování na některý objekt a že může být zvýšen na další iterátor v pořadí. Jedná se o minimální sadu funkcí, ale stačí, abyste mohli smysluplně mluvit o rozsahu iterátorů [First, Last) v kontextu členských funkcí třídy.

Volba typu kontejneru by měla obecně vycházet z typu vyhledávání a vkládání vyžadovaného aplikací. Asociativní kontejnery jsou optimalizovány pro operace vyhledávání, vkládání a odstranění. Členské funkce, které explicitně podporují tyto operace, jsou efektivní a jsou prováděny v čase, který je průměrně úměrný logaritmu počtu prvků v kontejneru. Vložení prvků zneplatní žádné iterátory a odebrání prvků zneplatní pouze iterátory, které ukazovaly na odebrané prvky.

Tento multimap kontejner by měl být asociativním kontejnerem podle výběru, když aplikace podmínky přidružuje hodnoty k jejich klíčům. Model pro tento typ struktury je uspořádaný seznam klíčových slov s přidruženými řetězcovými hodnotami poskytujícími například definice, kde slova nebyla vždy jedinečně definována. Pokud místo toho klíčová slova byla jedinečně definovaná tak, aby byly klíče jedinečné, bude objekt map správným kontejnerem výběru. Naopak pokud je pouze uložen seznam slov, bude objekt set tím správným kontejnerem. Pokud bylo povoleno více výskytů slov, pak multiset by byla vhodná struktura kontejneru.

Pořadí multimap , které řídí voláním uloženého objektu funkce typu key_compare. Tento uložený objekt je porovnávací funkce, ke které lze získat přístup voláním členské funkce key_comp. Obecně, tyto prvky musí být menší než srovnatelné pro toto pořadí, což znamená, že když jsou uvedeny dva prvky, může být stanoveno, zda jsou ekvivalentní (v tom smyslu, že ani jeden není menší než ten druhý), nebo že jeden je menší než druhý. To má za výsledek řazení mezi neekvivalentními prvky. Technicky je funkce porovnání binárním predikátem, který indukuje přísné slabé řazení, standardním matematickým způsobem. Binární predikát f(x,y) je objekt funkce, který má dva argumentové objekty x a y návratovou hodnotu true nebo false. Řazení stanovené pro množinu je striktní slabé řazení, pokud binární predikát je neflexivní, antisymetrické a tranzitivní a pokud je ekvivalence tranzitivní, kde dva objekty a jsou definovány x tak, aby byly ekvivalentní, pokud jsou oba f(x,y) a f(y,x) jsou false.y Pokud silnější podmínka rovnosti mezi klíči nahradí ekvivalenci, stane se pořadí celkovým (v tom smyslu, že všechny prvky jsou uspořádány ve vztahu k sobě navzájem) a odpovídající klíče budou od sebe nerozeznatelné.

Členové

Konstruktory

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

Typedefs

Název typu	Popis
`allocator_type`	Typ, který představuje `allocator` třídu objektu `multimap` .
`const_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst `const` prvek v objektu `multimap`.
`const_pointer`	Typ, který poskytuje ukazatel na `const` prvek v objektu `multimap`.
`const_reference`	Typ, který poskytuje odkaz na `const` prvek uložený v objektu `multimap` pro čtení a provádění `const` operací.
`const_reverse_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst libovolný `const` prvek v objektu `multimap`.
`difference_type`	Typ celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků `multimap` v rozsahu mezi prvky, na které odkazují iterátory.
`iterator`	Typ, který poskytuje rozdíl mezi dvěma iterátory, které odkazují na prvky ve stejném `multimap`.
`key_compare`	Typ, který poskytuje objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v objektu `multimap`.
`key_type`	Typ, který popisuje objekt klíče řazení, který tvoří každý prvek objektu `multimap`.
`mapped_type`	Typ, který představuje datový typ uložený v objektu `multimap`.
`pointer`	Typ, který poskytuje ukazatel na `const` prvek v objektu `multimap`.
`reference`	Typ, který poskytuje odkaz na prvek uložený v objektu `multimap`.
`reverse_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném směru `multimap`.
`size_type`	Typ celočíselného čísla bez znaménka, který poskytuje ukazatel na `const` prvek v objektu `multimap`.
`value_type`	Typ, který poskytuje objekt funkce, který může porovnat dva prvky jako klíče řazení k určení jejich relativního pořadí v objektu `multimap`.

Členské funkce

Členová funkce	Popis
`begin`	Vrátí iterátor adresování prvního prvku v objektu `multimap`.
`cbegin`	`const` Vrátí iterátor adresování prvního prvku v objektu `multimap`.
`cend`	`const` Vrátí iterátor, který řeší umístění úspěšné poslední prvek v objektu `multimap`.
`clear`	Vymaže všechny prvky .`multimap`
`contains`^C++20	Zkontroluje, zda existuje prvek se zadaným klíčem v souboru `multimap`.
`count`	Vrátí počet prvků v `multimap` klíči, jehož klíč odpovídá klíči zadanému parametrem.
`crbegin`	`const` Vrátí iterátor adresovaný prvním prvkem v obráceném směru `multimap`.
`crend`	`const` Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu `multimap`.
`emplace`	Vloží prvek vytvořený na místě do objektu `multimap`.
`emplace_hint`	Vloží prvek vytvořený na místě do objektu , s nápovědou `multimap`pro umístění.
`empty`	Testuje, jestli `multimap` je prázdný.
`end`	Vrátí iterátor, který řeší umístění úspěšné poslední prvek v objektu `multimap`.
`equal_range`	Vyhledá rozsahu prvků, kde klíče prvku odpovídají zadané hodnotě.
`erase`	Odebere prvek nebo rozsah prvků v `multimap` zadané pozici nebo odebere prvky, které odpovídají zadanému klíči.
`find`	Vrátí iterátor adresovaný první umístění prvku v objektu `multimap` , který má klíč ekvivalentní zadanému klíči.
`get_allocator`	Vrátí kopii objektu `allocator` použitého k vytvoření objektu `multimap`.
`insert`	Vloží prvek nebo oblast prvků do objektu `multimap`.
`key_comp`	Načte kopii objektu porovnání použitého k řazení klíčů v objektu `multimap`.
`lower_bound`	Vrátí iterátor na první prvek v objektu `multimap` s klíčem, který je roven nebo větší než zadaný klíč.
`max_size`	Vrátí maximální délku `multimap`.
`rbegin`	Vrátí iterátor adresovaný prvním prvkem v obráceném směru `multimap`.
`rend`	Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu `multimap`.
`size`	Vrátí počet prvků v sadě `multimap`.
`swap`	Vymění prvky dvou `multimap`s.
`upper_bound`	Vrátí iterátor na první prvek v objektu `multimap` , který má klíč větší než zadaný klíč.
`value_comp`	Členová funkce vrátí objekt funkce, který určuje pořadí prvků v objektu `multimap` porovnáním jejich klíčových hodnot.

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

Požadavky

Záhlaví:<map>

Obor názvů:std

Páry ( klíč, hodnota) jsou uloženy jako multimap objekty typu pair. Třída páru vyžaduje hlavičku <utility>, která je automaticky zahrnuta <map>.

`multimap::allocator_type`

Typ, který představuje třídu alokátoru objektu multimap .

typedef Allocator allocator_type;

Příklad

Podívejte se na příklad get_allocator použití .allocator_type

`multimap::begin`

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

const_iterator begin() const;

iterator begin();

Vrácená hodnota

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

Příklad

// 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 Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Vrácená hodnota

const Obousměrný iterátor s přístupem, který odkazuje na první prvek rozsahu, nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v oblasti.

Tuto členská funkce můžete použít místo begin() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

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

// i2 is Container<T>::const_iterator

`multimap::cend`

const Vrátí iterátor, který řeší umístění za posledním prvkem v rozsahu.

const_iterator cend() const;

Vrácená hodnota

const Obousměrný iterátor s přístupem, který odkazuje těsně za koncem rozsahu.

Poznámky

cend slouží k otestování, zda iterátor předal konec jeho rozsahu.

Tuto členská funkce můžete použít místo end() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje end() a cend().

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

// i2 is Container<T>::const_iterator

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

`multimap::clear`

Vymaže všechny prvky .multimap

void clear();

Příklad

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

// 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, který poskytuje obousměrný iterátor, který může číst const prvek v objektu multimap.

typedef implementation-defined const_iterator;

Poznámky

Typ const_iterator nelze použít k úpravě hodnoty elementu.

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

Pokud chcete odkazovat const_iteratorcIter na prvek v objektu multimap, použijte -> operátor.

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

Příklad

Podívejte se na příklad begin použití .const_iterator

`multimap::const_pointer`

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

typedef typename allocator_type::const_pointer const_pointer;

Poznámky

Typ const_pointer nelze použít k úpravě hodnoty elementu.

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

`multimap::const_reference`

Typ, který poskytuje odkaz na const prvek uložený v objektu multimap pro čtení a provádění const operací.

typedef typename allocator_type::const_reference const_reference;

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst libovolný const prvek v objektu multimap.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

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

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

Pokud chcete odkazovat const_reverse_iteratorcrIter na prvek ve vícemapách, použijte -> operátor.

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

Příklad

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

`multimap::contains`

Zkontrolujte, zda existuje prvek se zadaným klíčem v souboru multimap.

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

Parametry

K
Typ klíče.

key
Hodnota klíče prvku, kterou chcete vyhledat.

Vrácená hodnota

true je-li prvek nalezen v kontejneru; false Jinak.

Poznámky

contains() je nový v jazyce C++20. Pokud ho chcete použít, zadejte možnost kompilátoru /std:c++20 nebo novější.

template<class K> bool contains(const K& key) const Pouze se účastní řešení přetížení, pokud key_compare je transparentní. Další informace najdete v heterogenním vyhledávání v asociativních kontejnerech .

Příklad

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

Vrátí počet prvků, jejichž multimap klíče odpovídají klíči zadanému parametrem.

size_type count(const Key& key) const;

Parametry

key
Klíč prvků, které se mají spárovat z vícemap.

Vrácená hodnota

Počet prvků, jejichž klíče řazení odpovídají klíči parametru; 0, pokud multimap neobsahuje prvek s odpovídajícím klíčem.

Poznámky

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

lower_bound(key), upper_bound(key)

které mají hodnotu keyklíče .

Příklad

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

// 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 Vrátí iterátor adresovaný prvním prvkem v obráceném směru multimap.

const_reverse_iterator crbegin() const;

Vrácená hodnota

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

Poznámky

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

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

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

Příklad

// 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 Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu multimap.

const_reverse_iterator crend() const;

Vrácená hodnota

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

Poznámky

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

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

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

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

Příklad

// 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 celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků multimap v rozsahu mezi prvky, na které odkazují iterátory.

typedef typename allocator_type::difference_type difference_type;

Poznámky

Jedná se difference_type o typ vrácený při odečtení nebo zvýšení prostřednictvím iterátorů kontejneru. Obvykle difference_type se používá k reprezentaci počtu prvků v rozsahu [first, last) mezi iterátory first a last, zahrnuje prvek, na který odkazuje, a rozsah prvků až do, ale nezahrnuje prvek, na který first odkazuje last.

Ačkoli difference_type je k dispozici pro všechny iterátory, které splňují požadavky vstupního iterátoru, který zahrnuje třídu obousměrných iterátorů podporovaných reverzibilními kontejnery, jako je sada, odčítání mezi iterátory je podporováno pouze iterátory náhodného přístupu poskytované kontejnerem náhodného přístupu, jako je vektor.

Příklad

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

Vloží vytvořený prvek na místě (neprovádí se žádné operace kopírování ani přesunutí).

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

Parametry

args
Argumenty přeposlané k vytvoření prvku, který má být vložen do multimap.

Vrácená hodnota

Iterátor na nově vložený prvek.

Poznámky

Tato funkce zneplatní žádné odkazy na prvky kontejneru, ale může zneplatnit všechny iterátory kontejneru.

Pokud během vkládání dojde k výjimce, kontejner zůstane nezachovaný a výjimka se znovu zobrazí.

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

Příklad

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

Vloží prvek vytvořený na místě (neprovádí se žádné operace kopírování nebo přesunutí) s nápovědou k umístění.

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

Parametry

args
Argumenty přeposlané k vytvoření prvku, který má být vložen do multimap.

where
Místo zahájení vyhledání správného bodu vložení. (Pokud tento bod bezprostředně předchází where, může se místo logaritmického času objevit vložení v amortizovaném konstantním čase.)

Vrácená hodnota

Iterátor na nově vložený prvek.

Poznámky

Tato funkce zneplatní žádné odkazy na prvky kontejneru, ale může zneplatnit všechny iterátory kontejneru.

Pokud dojde při emplacementu k výjimce, stav kontejneru se nezmění.

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

Příklad kódu najdete v tématu map::emplace_hint.

`multimap::empty`

Testuje, jestli multimap je prázdný.

bool empty() const;

Vrácená hodnota

truemultimap pokud je prázdný; false pokud multimap je neprázdný.

Příklad

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

Vrátí iterátor za koncem.

const_iterator end() const;

iterator end();

Vrácená hodnota

Poslední iterátor. multimap Pokud je prázdný, pak multimap::end() == multimap::begin().

Poznámky

end slouží k otestování, zda iterátor prošel koncem jeho multimap.

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

Příklad kódu najdete v tématu multimap::find.

`multimap::equal_range`

Vyhledá rozsahu prvků, kde klíče prvku odpovídají zadané hodnotě.

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

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

Parametry

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

Vrácená hodnota

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

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

Příklad

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

Odebere prvek nebo rozsah prvků v multimap zadané pozici nebo odebere prvky, které odpovídají zadanému klíči.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametry

Where
Pozice prvku, který má být odebrán.

First
Pozice prvního prvku, který má být odebrán.

Last
Pozice bezprostředně za posledním prvkem, který má být odebrán.

Key
Klíč prvků, které se mají odebrat.

Vrácená hodnota

U prvních dvou členských funkcí určuje obousměrný iterátor, který určuje první prvek, který je nad rámec všech odebraných prvků, nebo prvek, který je koncem mapy, pokud žádný takový prvek neexistuje.

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

Poznámky

Příklad kódu najdete v tématu map::erase.

`multimap::find`

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

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

Vrácená hodnota

Iterátor, který odkazuje na umístění prvku se zadaným klíčem, nebo umístění úspěšné poslední prvek v multimap (multimap::end()), pokud se pro klíč nenajde žádná shoda.

Poznámky

Členská funkce vrátí iterátor, který odkazuje na prvek, jehož multimap klíč řazení je ekvivalentní klíči argumentu pod binárním predikátem, který indukuje řazení na základě porovnání.

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

Příklad

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

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

allocator_type get_allocator() const;

Vrácená hodnota

Alokátor používaný multimap.

Poznámky

Alokátory pro multimap třídu určují, jak třída spravuje úložiště. Výchozí alokátory dodávané s třídami kontejneru standardní knihovny C++ jsou dostatečné pro většinu programovacích potřeb. Psaní a používání vlastní třídy alokátoru je pokročilé téma jazyka C++.

Příklad

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

Vloží prvek nebo oblast prvků do objektu 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
Hodnota prvku, který má být vložen do multimap.

Where
Místo zahájení vyhledání správného bodu vložení. (Pokud tento bod bezprostředně předchází Where, může se místo logaritmického času objevit vložení v amortizovaném konstantním čase.)

ValTy
Parametr šablony, který určuje typ argumentu, který může mapa použít k vytvoření elementu value_type, a perfect-forwards Val jako argument.

First
Pozice prvního prvku, který chcete zkopírovat.

Last
Pozice bezprostředně za posledním prvkem, který chcete zkopírovat.

InputIterator
Argument funkce šablony, který splňuje požadavky iterátoruinput, který odkazuje na prvky typu, které lze použít k vytvoření value_type objektů.

IList
Ze initializer_list kterého chcete prvky zkopírovat.

Vrácená hodnota

Členské funkce s jedním prvkem vložení (1) a (2) vrátí iterátor do pozice, kde byl nový prvek vložen do multimap.

Členské funkce s jedním prvkem, (3) a (4), vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do multimap.

Poznámky

Touto funkcí nejsou neplatné žádné ukazatele ani odkazy, ale může zneplatnit všechny iterátory kontejneru.

Během vkládání pouze jednoho prvku, pokud je vyvolán výjimka, stav kontejneru se nezmění. Pokud je při vkládání více prvků vyvolána výjimka, kontejner zůstane v neurčeném, ale platném stavu.

Kontejner value_type je typedef, který patří do kontejneru a pro mapování multimap<K, V>::value_type je pair<const K, V>. Hodnota prvku je seřazená dvojice, ve které je první komponenta rovna hodnotě klíče a druhá komponenta je rovna datové hodnotě prvku.

Členová funkce oblasti (5) vloží sekvenci hodnot prvků do multimap prvku, který odpovídá každému prvku adresovanému iterátorem v oblasti [First, Last); proto Last se nevloží. Členské funkce end() kontejneru odkazuje na pozici těsně za posledním prvkem v kontejneru – například příkaz m.insert(v.begin(), v.end()); vloží všechny prvky v do m.

Funkce člena seznamu inicializátoru (6) používá initializer_list ke kopírování prvků do mapy.

Vložení prvku vytvořeného na místě – to znamená, že se neprovádí žádné operace kopírování nebo přesunutí – viz multimap::emplace a multimap::emplace_hint.

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst nebo upravovat libovolný prvek v objektu multimap.

typedef implementation-defined iterator;

Poznámky

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

Pokud chcete dereference iteratorIter odkazující na prvek v objektu multimap, použijte -> operátor.

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

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

Příklad

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

`multimap::key_comp`

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

key_compare key_comp() const;

Vrácená hodnota

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

Poznámky

Uložený objekt definuje členovu funkci.

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

vrátí hodnotu true, pokud x se přísně předchází y pořadí řazení.

Příklad

// 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, který poskytuje objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v objektu multimap.

typedef Traits key_compare;

Poznámky

key_compare je synonymem parametru Traitsšablony .

Další informace naleznete Traitsv multimap tématu Třída .

Příklad

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

`multimap::key_type`

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

typedef Key key_type;

Poznámky

key_type je synonymem parametru Keyšablony .

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

Příklad

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

`multimap::lower_bound`

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

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametry

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

Vrácená hodnota

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

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

Příklad

// 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, který představuje datový typ uložený v objektu multimap.

typedef Type mapped_type;

Poznámky

mapped_type je synonymem parametru Typešablony .

Další informace naleznete Typev multimap tématu Třída .

Příklad

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

`multimap::max_size`

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

size_type max_size() const;

Vrácená hodnota

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

Příklad

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

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

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
Třída úložiště alokátoru pro použití s tímto objektem multimap, kterou je standardně třída Allocator.

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

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

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

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

IList
Seznam initializer_list, ze kterého chcete kopírovat prvky.

Poznámky

Všechny konstruktory ukládají typ objektu alokátoru, který spravuje úložiště paměti pro objekt multimap a který lze později vrátit voláním get_allocator. Parametr allocator je často v deklaraci třídy vynechán a makra předběžného zpracování jsou použita k nahrazení alternativních alokátorů.

Všechny konstruktory inicializují své multimap.

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

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

Čtvrtý konstruktor určuje kopii multimapRight.

Pátý konstruktor určuje kopii přesunutím multimapdoprava.

6., 7. a 8. konstruktory kopírují členy objektu initializer_list.

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

Příklad

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

Nahradí prvky jiného multimap souboru kopií jiného multimap.

multimap& operator=(const multimap& right);

multimap& operator=(multimap&& right);

Parametry

right
Zkopírovaná multimap do souboru multimap.

Poznámky

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

Příklad

// 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, který poskytuje ukazatel na prvek v objektu multimap.

typedef typename allocator_type::pointer pointer;

Poznámky

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

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

`multimap::rbegin`

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Vrácená hodnota

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

Poznámky

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

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

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

Příklad

// 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, který poskytuje odkaz na prvek uložený v objektu multimap.

typedef typename allocator_type::reference reference;

Příklad

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

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Vrácená hodnota

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

Poznámky

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

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

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

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

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném směru multimap.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ reverse_iterator se používá k iteraci obráceně multimap .

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

Pokud chcete odkazovat reverse_iteratorrIter na prvek v objektu multimap, použijte -> operátor.

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

Příklad

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

`multimap::size`

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

size_type size() const;

Vrácená hodnota

Aktuální délka multimap.

Příklad

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

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

Typ celočíselného čísla bez znaménka, který spočítá počet prvků v objektu multimap.

typedef typename allocator_type::size_type size_type;

Příklad

Příklad deklarování a použití najdete v příkladu size postupu deklarace a použití. size_type

`multimap::swap`

Vymění prvky dvou multimaps.

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

Parametry

right
Poskytování multimap prvků, které mají být prohozeny, nebo jejichž multimap prvky mají být vyměňovány s prvky multimapleft.

Poznámky

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

Příklad

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

iterator Vrátí první prvek v objektumultimap, který má klíč větší než zadaný klíč.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametry

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

Vrácená hodnota

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

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

Příklad

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

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

value_compare value_comp() const;

Vrácená hodnota

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

Poznámky

Pro , pokud dva prvky e1(k1, d1) a e2(k2, d2) jsou objekty typu value_type, kde k1 a k2 jsou jejich klíče typu key_type a d1 jsou d2 jejich data typu mapped_type, pak m.value_comp(e1, e2) je ekvivalentní m.key_comp(k1, k2).multimapm

Příklad

// 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, který představuje typ objektu uloženého jako prvek v mapě.

typedef pair<const Key, Type> value_type;

Příklad

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

Viz také

Kontejnery
Bezpečný přístup z více vláken ve standardní knihovně C++
Standardní knihovna C++ – referenční dokumentace

multimap Třída

Syntaxe

Parametry

Poznámky

Členové

Konstruktory

Typedefs

Členské funkce

Požadavky

multimap::allocator_type

Příklad

multimap::begin

Vrácená hodnota

Příklad

multimap::cbegin

Vrácená hodnota

Poznámky

multimap::cend

Vrácená hodnota

Poznámky

multimap::clear

Příklad

multimap::const_iterator

Poznámky

Příklad

multimap::const_pointer

Poznámky

multimap::const_reference

Příklad

multimap::const_reverse_iterator

Poznámky

Příklad

multimap::contains

Parametry

Vrácená hodnota

Poznámky

Příklad

multimap::count

Parametry

Vrácená hodnota

Poznámky

Příklad

multimap::crbegin

Vrácená hodnota

Poznámky

Příklad

multimap::crend

Vrácená hodnota

Poznámky

Příklad

multimap::difference_type

Poznámky

Příklad

multimap::emplace

Parametry

Vrácená hodnota

Poznámky

Příklad

multimap::emplace_hint

Parametry

Vrácená hodnota

Poznámky

multimap::empty

Vrácená hodnota

Příklad

multimap::end

Vrácená hodnota

Poznámky

multimap::equal_range

Parametry

Vrácená hodnota

Příklad

multimap::erase

Parametry

Vrácená hodnota

Poznámky

multimap::find

Parametry

Vrácená hodnota

Poznámky

`multimap` Třída

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