`multimap` (STL/CLR)

Článek
10/12/2023

Třída šablony popisuje objekt, který řídí různou délkovou sekvenci prvků, které mají obousměrný přístup. Kontejner slouží multimap ke správě posloupnosti prvků jako (téměř) vyváženého uspořádaného stromu uzlů, přičemž každý ukládá jeden prvek. Prvek se skládá z klíče, pro řazení sekvence a mapované hodnoty, která jde podél jízdy.

V následujícím GValue popisu je stejný jako:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

kde:

GKey je stejná jako Key v případě, že se jedná o typ odkazu, v takovém případě se jedná o typ odkazu. Key^

GMapped je stejná jako Mapped v případě, že se jedná o typ odkazu, v takovém případě se jedná o typ odkazu. Mapped^

Syntaxe

template<typename Key,
    typename Mapped>
    ref class multimap
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::ITree<Gkey, GValue>
    { ..... };

Parametry

Key
Typ klíčové komponenty prvku v řízené sekvenci.

Mapped
Typ druhé komponenty prvku v řízené sekvenci.

Požadavky

Header:<cliext/map>

Obor názvů: cliext

Deklarace

Definice typu	Popis
`multimap::const_iterator`	Typ konstantního iterátoru řízené sekvence
`multimap::const_reference`	Typ konstantního odkazu na prvek
`multimap::const_reverse_iterator`	Typ konstantního zpětného iterátoru pro řízenou sekvenci.
`multimap::difference_type`	Typ (pravděpodobně podepsané) vzdálenosti mezi dvěma prvky.
`multimap::generic_container`	Typ obecného rozhraní pro kontejner.
`multimap::generic_iterator`	Typ iterátoru pro obecné rozhraní kontejneru.
`multimap::generic_reverse_iterator`	Typ zpětného iterátoru pro obecné rozhraní kontejneru.
`multimap::generic_value`	Typ elementu pro obecné rozhraní kontejneru.
`multimap::iterator`	Typ iterátoru řízené sekvence
`multimap::key_compare`	Pořadí delegátů pro dva klíče.
`multimap::key_type`	Typ klíče řazení
`multimap::mapped_type`	Typ mapované hodnoty přidružené ke každému klíči.
`multimap::reference`	Typ odkazu na prvek
`multimap::reverse_iterator`	Typ zpětné iterátoru pro řízenou sekvenci.
`multimap::size_type`	Typ (nezáporné) vzdálenosti mezi dvěma prvky.
`multimap::value_compare`	Delegát řazení pro dvě hodnoty prvků.
`multimap::value_type`	Typ prvku

Členová funkce	Popis
`multimap::begin`	Určuje začátek řízené sekvence.
`multimap::clear`	Odebere všechny prvky.
`multimap::count`	Počítá prvky odpovídající zadanému klíči.
`multimap::empty`	Zkouší, zda nejsou přítomny žádné prvky.
`multimap::end`	Určuje konec řízené sekvence.
`multimap::equal_range`	Najde rozsah, který odpovídá zadanému klíči.
`multimap::erase`	Odebere prvky v určených pozicích.
`multimap::find`	Vyhledá prvek, který odpovídá zadanému klíči.
`multimap::insert`	Přidá prvky.
`multimap::key_comp`	Zkopíruje delegáta řazení pro dva klíče.
`multimap::lower_bound`	Najde začátek rozsahu, který odpovídá zadanému klíči.
`multimap::make_value`	Vytvoří objekt hodnoty.
`multimap::multimap`	Sestaví objekt kontejneru.
`multimap::rbegin`	Určuje začátek obrácené řízené sekvence.
`multimap::rend`	Určuje konec obrácené řízené sekvence.
`multimap::size`	Spočítá počet prvků.
`multimap::swap`	Zamění obsah dvou kontejnerů.
`multimap::to_array`	Zkopíruje řízenou sekvenci do nového pole.
`multimap::upper_bound`	Najde konec rozsahu, který odpovídá zadanému klíči.
`multimap::value_comp`	Zkopíruje delegáta řazení pro dvě hodnoty prvků.

Operátor	Popis
`multimap::operator=`	Nahradí řízenou sekvenci.
`operator!=` (multimap)	Určuje, jestli se objekt nerovná jinému `multimap` `multimap` objektu.
`operator<` (multimap)	Určuje, zda `multimap` je objekt menší než jiný `multimap` objekt.
`operator<=` (multimap)	Určuje, zda `multimap` je objekt menší nebo roven jinému `multimap` objektu.
`operator==` (multimap)	Určuje, zda je `multimap` objekt roven jinému `multimap` objektu.
`operator>` (multimap)	Určuje, zda `multimap` je objekt větší než jiný `multimap` objekt.
`operator>=` (multimap)	Určuje, zda `multimap` je objekt větší nebo roven jinému `multimap` objektu.

Rozhraní

Rozhraní	Popis
ICloneable	Duplikovat objekt
IEnumerable	Sekvencovat prvky.
ICollection	Udržujte skupinu prvků.
IEnumerable<T>	Sekvencovat přes typové prvky.
ICollection<T>	Udržujte skupinu typed elementů.
`ITree<Key, Value>`	Udržujte obecný kontejner.

Poznámky

Objekt přidělí a uvolní úložiště pro sekvenci, které řídí jako jednotlivé uzly. Vloží prvky do (téměř) vyváženého stromu, který udržuje seřazený tak, že mění vazby mezi uzly, nikdy zkopírováním obsahu jednoho uzlu do druhého. To znamená, že můžete vložit a odebrat prvky volně bez rušivých zbývajících prvků.

Objekt objednává sekvenci, kterou řídí voláním uloženého delegáta objekt typu multimap::key_compare. Při vytváření vícemap můžete určit uložený objekt delegáta; Pokud zadáte žádný objekt delegáta, výchozí hodnota je porovnání operator<(key_type, key_type). K tomuto uloženému objektu přistupujete voláním členské funkce multimap::key_comp.

Takový objekt delegáta musí být nastaven striktní slabé řazení klíčů typu multimap::key_type. To znamená, že pro všechny dva klíče X a Y:

key_comp()(X, Y) vrátí stejný logický výsledek při každém volání.

Pokud key_comp()(X, Y) je pravda, key_comp()(Y, X) musí být false.

Pokud key_comp()(X, Y) je pravda, pak X je řečeno, že je objednán před Y.

Pokud !key_comp()(X, Y) && !key_comp()(Y, X) je pravda, znamená to Y X, že mají ekvivalentní řazení.

Pro každý prvek X , který předchází Y řízené sekvenci, key_comp()(Y, X) je false. (U výchozího objektu delegáta klíče nikdy nezmenší hodnotu.) Na rozdíl od mapování tříd šablony (STL/CLR) objekt třídy multimap šablony nevyžaduje, aby klíče pro všechny prvky byly jedinečné. (Dva nebo více klíčů můžou mít ekvivalentní řazení.)

Každý prvek obsahuje samostatný klíč a mapovanou hodnotu. Sekvence je reprezentována způsobem, který umožňuje vyhledávání, vložení a odebrání libovolného prvku v logaritmickém čase. To znamená, že počet operací je úměrný logaritmus počtu prvků v posloupnosti. Vložení prvku navíc zneplatní žádné iterátory a odebrání prvku zneplatní pouze iterátory, které ukazují na odebraný prvek.

Podporuje multimap obousměrné iterátory, což znamená, že můžete přejít k sousedním prvkům, které mají iterátor, který určuje prvek v řízené sekvenci. Speciální hlavní uzel odpovídá iterátoru vrácené end(). Pokud existuje, můžete tento iterátor dekrementovat, abyste dosáhli posledního prvku v řízené sekvenci. Můžete zvýšit multimap iterátor tak, aby se dostal do hlavního uzlu, a pak se porovná se rovna end(). Nemůžete ale odvodit iterátor vrácený end().

Prvek nelze odkazovat multimap přímo na jeho číselnou pozici. To vyžaduje iterátor náhodného přístupu.

multimap Iterátor ukládá popisovač do přidruženého multimap uzlu, který pak ukládá popisovač do přidruženého kontejneru. Iterátory můžete používat pouze s přidruženými objekty kontejneru. multimap Iterátor zůstane platný, pokud je přidružený multimap uzel přidružený k některé multimapě. Kromě toho je platný iterátor dereferencovatelný. Můžete ji použít pro přístup k hodnotě prvku, kterou určuje, nebo ji změnit, pokud není rovna end().

Vymazání nebo odebrání prvku volá destruktor pro uloženou hodnotu. Zničení kontejneru vymaže všechny prvky. Kontejner, jehož typ elementu je ref třída zajišťuje, že žádné prvky nedosáhly kontejneru. Kontejner popisovačů ale nezničí jeho prvky.

Členové

`multimap::begin`

Určuje začátek řízené sekvence.

Syntaxe

iterator begin();

Poznámky

Členová funkce vrátí obousměrný iterátor, který určuje první prvek řízené sekvence nebo těsně za koncem prázdné sekvence. Použijete ho k získání iterátoru, který určuje current začátek řízené sekvence, ale jeho stav se může změnit, pokud se změní délka řízené sekvence.

Příklad

// cliext_multimap_begin.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items
    Mymultimap::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*++begin() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*begin() = [a 1]
*++begin() = [b 2]

`multimap::clear`

Odebere všechny prvky.

Syntaxe

void clear();

Poznámky

Člen funkce efektivně volá erase(begin(), end()). Použijete ho k zajištění, že řízená sekvence je prázdná.

Příklad

// cliext_multimap_clear.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2]
size() = 0

`multimap::const_iterator`

Typ konstantního iterátoru řízené sekvence

Syntaxe

typedef T2 const_iterator;

Poznámky

Typ popisuje objekt nezadaného typu T2 , který může sloužit jako konstantní obousměrný iterátor pro řízenou sekvenci.

Příklad

// cliext_multimap_const_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymultimap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("[{0} {1}] ", cit->first, cit->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`multimap::const_reference`

Typ konstantního odkazu na prvek

Syntaxe

typedef value_type% const_reference;

Poznámky

Typ popisuje konstantní odkaz na prvek.

Příklad

// cliext_multimap_const_reference.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymultimap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Mymultimap::const_reference cref = *cit;
        System::Console::Write("[{0} {1}] ", cref->first, cref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`multimap::const_reverse_iterator`

Typ konstantního zpětného iterátoru pro řízenou sekvenci.

Syntaxe

typedef T4 const_reverse_iterator;

Poznámky

Typ popisuje objekt nezadaného typu T4 , který může sloužit jako konstantní reverzní iterátor pro řízenou sekvenci.

Příklad

// cliext_multimap_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Mymultimap::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("[{0} {1}] ", crit->first, crit->second);
    System::Console::WriteLine();
    return (0);
    }

[c 3] [b 2] [a 1]

`multimap::count`

Zjistí počet prvků odpovídající zadanému klíči.

Syntaxe

size_type count(key_type key);

Parametry

key
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Členová funkce vrátí počet prvků v řízené sekvenci, které mají ekvivalentní řazení s key. Použijete ho k určení počtu prvků aktuálně v řízené sekvenci, které odpovídají zadanému klíči.

Příklad

// cliext_multimap_count.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

[a 1] [b 2] [c 3]
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

`multimap::difference_type`

Typy podepsané vzdálenosti mezi dvěma prvky.

Syntaxe

typedef int difference_type;

Poznámky

Typ popisuje pravděpodobně záporný počet prvků.

Příklad

// cliext_multimap_difference_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Mymultimap::difference_type diff = 0;
    for (Mymultimap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Mymultimap::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

[a 1] [b 2] [c 3]
end()-begin() = 3
begin()-end() = -3

`multimap::empty`

Zkouší, zda nejsou přítomny žádné prvky.

Syntaxe

bool empty();

Poznámky

Členová funkce vrátí hodnotu true pro prázdnou řízenou sekvenci. Je to ekvivalent .size() == 0 Použijete ho k otestování multimap , jestli je prázdný.

Příklad

// cliext_multimap_empty.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 3
empty() = False
size() = 0
empty() = True

`multimap::end`

Určuje konec řízené sekvence.

Syntaxe

iterator end();

Poznámky

Členová funkce vrátí obousměrný iterátor, který odkazuje těsně za koncem řízené sekvence. Použijete jej k získání iterátoru, který určuje konec řízené sekvence; jeho stav se nezmění, pokud se změní délka řízené sekvence.

Příklad

// cliext_multimap_end.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect last two items
    Mymultimap::iterator it = c1.end();
    --it;
    --it;
    System::Console::WriteLine("*-- --end() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*--end() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*-- --end() = [b 2]
*--end() = [c 3]

`multimap::equal_range`

Najde rozsah, který odpovídá zadanému klíči.

Syntaxe

pair_iter_iter equal_range(key_type key);

Parametry

key
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Metoda vrátí dvojici iterátorů, pair_iter_iter(lower_bound(key), upper_bound(key)). Použijete ho k určení rozsahu prvků aktuálně v řízené sekvenci, které odpovídají zadanému klíči.

Příklad

// cliext_multimap_equal_range.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
typedef Mymultimap::pair_iter_iter Pairii;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("[{0} {1}] ",
            pair1.first->first, pair1.first->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
equal_range(L'x') empty = True
[b 2]

`multimap::erase`

Odebere prvky v určených pozicích.

Syntaxe

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

Parametry

first
Začátek rozsahu, který chcete vymazat.

key
Hodnota klíče, kterou chcete vymazat.

last
Konec rozsahu, který chcete vymazat.

where
Prvek, který chcete vymazat.

Poznámky

První člen funkce odebere prvek řízené sekvence, na kterou whereodkazuje , a vrátí iterátor, který určuje první prvek, který zůstává za odebraným prvkem, nebo end() pokud takový prvek neexistuje. Použijete ho k odebrání jednoho prvku.

Druhá členová funkce odebere prvky řízené sekvence v oblasti [first, last) a vrátí iterátor, který určuje první prvek, který zůstává nad rámec všech prvků odebraných, nebo end() pokud takový prvek neexistuje. Použijete ho k odebrání nulových nebo více souvislých prvků.

Třetí člen funkce odebere libovolný prvek řízené sekvence, jehož klíč má ekvivalentní pořadí k key, a vrátí počet odebraných prvků. Použijete ho k odebrání a počítání všech prvků, které odpovídají zadanému klíči.

Vymazání každého prvku trvá určitou dobu úměrné logaritmus počtu prvků v řízené sekvenci.

Příklad

// cliext_multimap_erase.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    cliext::multimap<wchar_t, int> c1;
    c1.insert(cliext::multimap<wchar_t, int>::make_value(L'a', 1));
    c1.insert(cliext::multimap<wchar_t, int>::make_value(L'b', 2));
    c1.insert(cliext::multimap<wchar_t, int>::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::multimap<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase an element and reinspect
    cliext::multimap<wchar_t, int>::iterator it =
        c1.erase(c1.begin());
    System::Console::WriteLine("erase(begin()) = [{0} {1}]",
        it->first, it->second);

    // add elements and display " b c d e"
    c1.insert(cliext::multimap<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::multimap<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::multimap<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase all but end
    it = c1.end();
    it = c1.erase(c1.begin(), --it);
    System::Console::WriteLine("erase(begin(), end()-1) = [{0} {1}]",
        it->first, it->second);
    System::Console::WriteLine("size() = {0}", c1.size());

    // erase end
    System::Console::WriteLine("erase(L'x') = {0}", c1.erase(L'x'));
    System::Console::WriteLine("erase(L'e') = {0}", c1.erase(L'e'));
    return (0);
    }

[a 1] [b 2] [c 3]
erase(begin()) = [b 2]
[b 2] [c 3] [d 4] [e 5]
erase(begin(), end()-1) = [e 5]
size() = 1
erase(L'x') = 0
erase(L'e') = 1

`multimap::find`

Vyhledá prvek, který odpovídá zadanému klíči.

Syntaxe

iterator find(key_type key);

Parametry

key
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Pokud má alespoň jeden prvek v řízené sekvenci ekvivalentní řazení s key, členské funkce vrátí iterátor označující jeden z těchto prvků, jinak vrátíend(). Použijete ho k vyhledání prvku aktuálně v řízené sekvenci, která odpovídá zadanému klíči.

Příklad

// cliext_multimap_find.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());

    Mymultimap::iterator it = c1.find(L'b');
    System::Console::WriteLine("find {0} = [{1} {2}]",
        L'b', it->first, it->second);

    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

[a 1] [b 2] [c 3]
find A = False
find b = [b 2]
find C = False

`multimap::generic_container`

Typ obecného rozhraní pro kontejner.

Syntaxe

typedef Microsoft::VisualC::StlClr::
    ITree<GKey, GValue>
    generic_container;

Poznámky

Typ popisuje obecné rozhraní pro tuto třídu kontejneru šablony.

Příklad

// cliext_multimap_generic_container.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymultimap::generic_container^ gc1 = %c1;
    for each (Mymultimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(Mymultimap::make_value(L'd', 4));
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(Mymultimap::make_value(L'e', 5));
    for each (Mymultimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3] [d 4] [e 5]

`multimap::generic_iterator`

Typ iterátoru pro použití s obecným rozhraním kontejneru.

Syntaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Poznámky

Typ popisuje obecný iterátor, který lze použít s obecným rozhraním pro tuto třídu kontejneru šablony.

Příklad

// cliext_multimap_generic_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymultimap::generic_container^ gc1 = %c1;
    for each (Mymultimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymultimap::generic_iterator gcit = gc1->begin();
    Mymultimap::generic_value gcval = *gcit;
    System::Console::Write("[{0} {1}] ", gcval->first, gcval->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

`multimap::generic_reverse_iterator`

Typ zpětného iterátoru pro použití s obecným rozhraním kontejneru.

Syntaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Poznámky

Typ popisuje obecný reverzní iterátor, který lze použít s obecným rozhraním pro tuto třídu kontejneru šablony.

Příklad

// cliext_multimap_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymultimap::generic_container^ gc1 = %c1;
    for each (Mymultimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymultimap::generic_reverse_iterator gcit = gc1->rbegin();
    Mymultimap::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3]

`multimap::generic_value`

Typ elementu pro použití s obecným rozhraním kontejneru.

Syntaxe

typedef GValue generic_value;

Poznámky

Typ popisuje objekt typu GValue , který popisuje uloženou hodnotu elementu pro použití s obecným rozhraním pro tuto třídu kontejneru šablony.

Příklad

// cliext_multimap_generic_value.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymultimap::generic_container^ gc1 = %c1;
    for each (Mymultimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymultimap::generic_iterator gcit = gc1->begin();
    Mymultimap::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

`multimap::insert`

Přidá prvky.

Syntaxe

iterator insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Parametry

first
Začátek oblasti, která se má vložit.

last
Konec oblasti, která se má vložit.

right
Výčet pro vložení

val
Hodnota klíče, kterou chcete vložit.

where
Kde v kontejneru vložit (pouze nápověda).

Poznámky

Každá z členských funkcí vloží sekvenci určenou zbývajícími operandy.

První člen funkce vloží prvek s hodnotou vala vrátí iterátor, který určuje nově vložený prvek. Použijete ho k vložení jednoho prvku.

Druhá členová funkce vloží prvek s hodnotou valpomocí where nápovědy (ke zlepšení výkonu) a vrátí iterátor, který označuje nově vložený prvek. Slouží k vložení jednoho prvku, který může být vedle prvku, který znáte.

Třetí členová funkce vloží sekvenci [first, last). Slouží k vložení nuly nebo více prvků zkopírovaných z jiné sekvence.

Čtvrtá členová funkce vloží sekvenci určenou rightfunkcí . Slouží k vložení sekvence popsané enumerátorem.

Každé vložení prvku trvá určitou dobu úměrné logaritmus počtu prvků v řízené sekvenci. Vložení může nastat v amortizované konstantní době, ale vzhledem k nápovědě, která označuje prvek vedle kurzoru.

Příklad

// cliext_multimap_insert.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    Mymultimap::iterator it =
        c1.insert(Mymultimap::make_value(L'x', 24));
    System::Console::WriteLine("insert([L'x' 24]) = [{0} {1}]",
        it->first, it->second);

    it = c1.insert(Mymultimap::make_value(L'b', 2));
    System::Console::WriteLine("insert([L'b' 2]) = [{0} {1}]",
        it->first, it->second);

    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value with hint
    it = c1.insert(c1.begin(), Mymultimap::make_value(L'y', 25));
    System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
        it->first, it->second);
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an iterator range
    Mymultimap c2;
    it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an enumeration
    Mymultimap c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Mymultimap::value_type>^)%c1);
    for each (Mymultimap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
insert([L'x' 24]) = [x 24]
insert([L'b' 2]) = [b 2]
[a 1] [b 2] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [b 2] [c 3] [x 24]
[a 1] [b 2] [b 2] [c 3] [x 24] [y 25]

`multimap::iterator`

Typ iterátoru řízené sekvence

Syntaxe

typedef T1 iterator;

Poznámky

Typ popisuje objekt nezadaného typu T1 , který může sloužit jako obousměrný iterátor pro řízenou sekvenci.

Příklad

// cliext_multimap_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymultimap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("[{0} {1}] ", it->first, it->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`multimap::key_comp`

Zkopíruje delegáta řazení pro dva klíče.

Syntaxe

key_compare^key_comp();

Poznámky

Členová funkce vrátí delegáta řazení, který se používá k seřazení řízené sekvence. Použijete ho k porovnání dvou klíčů.

Příklad

// cliext_multimap_key_comp.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    Mymultimap::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mymultimap c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`multimap::key_compare`

Pořadí delegátů pro dva klíče.

Syntaxe

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Poznámky

Typ je synonymem pro delegáta, který určuje pořadí jeho klíčových argumentů.

Příklad

// cliext_multimap_key_compare.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    Mymultimap::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mymultimap c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`multimap::key_type`

Typ klíče řazení

Syntaxe

typedef Key key_type;

Poznámky

Typ je synonymem pro parametr Keyšablony .

Příklad

// cliext_multimap_key_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using key_type
    for (Mymultimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Mymultimap::key_type val = it->first;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`multimap::lower_bound`

Najde začátek rozsahu, který odpovídá zadanému klíči.

Syntaxe

iterator lower_bound(key_type key);

Parametry

key
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Člen funkce určuje první prvek X v řízené sekvenci, který má ekvivalentní pořadí .key Pokud takový prvek neexistuje, vrátí end(); v opačném případě vrátí iterátor, který určuje X. Použijete ho k vyhledání začátku sekvence prvků aktuálně v řízené sekvenci, která odpovídá zadanému klíči.

Příklad

// cliext_multimap_lower_bound.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    Mymultimap::iterator it = c1.lower_bound(L'a');
    System::Console::WriteLine("*lower_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.lower_bound(L'b');
    System::Console::WriteLine("*lower_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
lower_bound(L'x')==end() = True
*lower_bound(L'a') = [a 1]
*lower_bound(L'b') = [b 2]

`multimap::make_value`

Vytvoří objekt hodnoty.

Syntaxe

static value_type make_value(key_type key, mapped_type mapped);

Parametry

key
Hodnota klíče, kterou chcete použít.

mapped
Namapovaná hodnota, kterou chcete vyhledat.

Poznámky

Členské funkce vrátí objekt, value_type jehož klíč je key a jehož mapovaná hodnota je mapped. Slouží k vytvoření objektu vhodného pro použití s několika dalšími členskými funkcemi.

Příklad

// cliext_multimap_make_value.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`multimap::mapped_type`

Typ mapované hodnoty přiřazené ke každému klíči

Syntaxe

typedef Mapped mapped_type;

Poznámky

Typ je synonymem pro parametr Mappedšablony .

Příklad

// cliext_multimap_mapped_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using mapped_type
    for (Mymultimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in mapped_type object
        Mymultimap::mapped_type val = it->second;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

1 2 3

`multimap::multimap`

Sestaví objekt kontejneru.

Syntaxe

multimap();
explicit multimap(key_compare^ pred);
multimap(multimap<Key, Mapped>% right);
multimap(multimap<Key, Mapped>^ right);
template<typename InIter>
    multimapmultimap(InIter first, InIter last);
template<typename InIter>
    multimap(InIter first, InIter last,
        key_compare^ pred);
multimap(System::Collections::Generic::IEnumerable<GValue>^ right);
multimap(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);

Parametry

first
Začátek oblasti, která se má vložit.

last
Konec oblasti, která se má vložit.

pred
Řazení predikátu pro řízenou sekvenci

right
Objekt nebo oblast, které chcete vložit.

Poznámky

Konstruktor:

multimap();

inicializuje řízenou sekvenci bez prvků s výchozím predikátem key_compare()řazení . Slouží k určení prázdné počáteční řízené sekvence s výchozím predikátem řazení.

Konstruktor:

explicit multimap(key_compare^ pred);

inicializuje řízenou sekvenci bez prvků s predikátem predřazení . Použijete ho k určení prázdné počáteční řízené sekvence se zadaným predikátem řazení.

Konstruktor:

multimap(multimap<Key, Mapped>% right);

inicializuje řízenou sekvenci [right.begin(), right.end()), s výchozím predikátem řazení. Slouží k určení počáteční řízené sekvence, která je kopií sekvence řízené objektem multimap right, s výchozím pořadím predikát.

Konstruktor:

multimap(multimap<Key, Mapped>^ right);

inicializuje řízenou sekvenci [right->begin(), right->end()), s výchozím predikátem řazení. Slouží k určení počáteční řízené sekvence, která je kopií sekvence řízené objektem multimap right, s výchozím pořadím predikát.

Konstruktor:

template<typename InIter> multimap(InIter first, InIter last);

inicializuje řízenou sekvenci [first, last), s výchozím predikátem řazení. Použijete ho k vytvoření řízené sekvence jako kopie jiné sekvence s výchozím predikátem řazení.

Konstruktor:

template<typename InIter> multimap(InIter first, InIter last, key_compare^ pred);

inicializuje řízenou sekvenci [first, last), s pořadím predikát pred. Použijete ji k tomu, aby řízená sekvence byla kopií jiné sekvence se zadaným predikátem řazení.

Konstruktor:

multimap(System::Collections::Generic::IEnumerable<Key>^ right);

inicializuje řízenou sekvenci sekvencí určenou enumerátorem right, s výchozím predikátem řazení. Použijete ji k tomu, aby řízená sekvence byla kopií jiné sekvence popsané enumerátorem s výchozím predikátem řazení.

Konstruktor:

multimap(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

inicializuje řízenou sekvenci se sekvencí určenou enumerátorem rights predikátem predřazení . Použijete ho k tomu, aby řízená sekvence byla kopií jiné sekvence popsané enumerátorem se zadaným predikátem řazení.

Příklad

// cliext_multimap_construct.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
// construct an empty container
    Mymultimap c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an ordering rule
    Mymultimap c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range
    Mymultimap c3(c1.begin(), c1.end());
    for each (Mymultimap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Mymultimap c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (Mymultimap::value_type elem in c4)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration
    Mymultimap c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Mymultimap::value_type>^)%c3);
    for each (Mymultimap::value_type elem in c5)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Mymultimap c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Mymultimap::value_type>^)%c3,
                cliext::greater_equal<wchar_t>());
    for each (Mymultimap::value_type elem in c6)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying another container
    Mymultimap c7(c4);
    for each (Mymultimap::value_type elem in c7)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying a container handle
    Mymultimap c8(%c3);
    for each (Mymultimap::value_type elem in c8)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
[a 1] [b 2] [c 3]
size() = 0
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]

`multimap::operator=`

Nahradí řízenou sekvenci.

Syntaxe

multimap<Key, Mapped>% operator=(multimap<Key, Mapped>% right);

Parametry

right
Kontejner, který se má zkopírovat.

Poznámky

Operátor člena zkopíruje right objekt a pak vrátí *this. Slouží k nahrazení řízené sekvence kopií řízené sekvence v right.

Příklad

// cliext_multimap_operator_as.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymultimap c2;
    c2 = c1;
// display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]

`multimap::rbegin`

Určuje začátek obrácené řízené sekvence.

Syntaxe

reverse_iterator rbegin();

Poznámky

Členová funkce vrátí reverzní iterátor, který určuje poslední prvek řízené sekvence nebo těsně za začátek prázdné sekvence. Proto určuje beginning zpětnou sekvenci. Použijete ho k získání iterátoru, který určuje current začátek řízené sekvence zobrazené v obráceném pořadí, ale její stav se může změnit, pokud se délka řízené sekvence změní.

Příklad

// cliext_multimap_rbegin.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Mymultimap::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*++rbegin() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*rbegin() = [c 3]
*++rbegin() = [b 2]

`multimap::reference`

Typ odkazu na prvek

Syntaxe

typedef value_type% reference;

Poznámky

Typ popisuje odkaz na prvek.

Příklad

// cliext_multimap_reference.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymultimap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Mymultimap::reference ref = *it;
        System::Console::Write("[{0} {1}] ", ref->first, ref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`multimap::rend`

Určuje konec obrácené řízené sekvence.

Syntaxe

reverse_iterator rend();

Poznámky

Členová funkce vrátí reverzní iterátor, který odkazuje přímo na začátek řízené sekvence. Proto určuje end zpětnou sekvenci. Použijete ho k získání iterátoru, který určuje current konec řízené sekvence zobrazené v obráceném pořadí, ale jeho stav se může změnit, pokud se délka řízené sekvence změní.

Příklad

// cliext_multimap_rend.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Mymultimap::reverse_iterator rit = c1.rend();
    --rit;
    --rit;
    System::Console::WriteLine("*-- --rend() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*--rend() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*-- --rend() = [b 2]
*--rend() = [a 1]

`multimap::reverse_iterator`

Typ zpětné iterátoru pro řízenou sekvenci.

Syntaxe

typedef T3 reverse_iterator;

Poznámky

Typ popisuje objekt nespecifikovaného typu T3 , který může sloužit jako reverzní iterátor řízené sekvence.

Příklad

// cliext_multimap_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Mymultimap::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("[{0} {1}] ", rit->first, rit->second);
    System::Console::WriteLine();
    return (0);
    }

[c 3] [b 2] [a 1]

`multimap::size`

Spočítá počet prvků.

Syntaxe

size_type size();

Poznámky

Členová funkce vrátí délku řízené sekvence. Použijete ho k určení počtu prvků aktuálně v řízené sekvenci. Pokud vám záleží na tom, zda sekvence má nenulové velikosti, podívejte se empty()na .

Příklad

// cliext_multimap_size.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(Mymultimap::make_value(L'd', 4));
    c1.insert(Mymultimap::make_value(L'e', 5));
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0 after clearing
size() = 2 after adding 2

`multimap::size_type`

Typ vzdálenosti se znaménkem mezi dvěma prvky

Syntaxe

typedef int size_type;

Poznámky

Typ popisuje nezáporný počet prvků.

Příklad

// cliext_multimap_size_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Mymultimap::size_type diff = 0;
    for (Mymultimap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

[a 1] [b 2] [c 3]
end()-begin() = 3

`multimap::swap`

Zamění obsah dvou kontejnerů.

Syntaxe

void swap(multimap<Key, Mapped>% right);

Parametry

right
Kontejner pro prohození obsahu.

Poznámky

Členová funkce prohodí řízené sekvence mezi this a right. Provede to v konstantním čase a nevyvolá žádné výjimky. Použijete ho jako rychlý způsob výměny obsahu dvou kontejnerů.

Příklad

// cliext_multimap_swap.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Mymultimap c2;
    c2.insert(Mymultimap::make_value(L'd', 4));
    c2.insert(Mymultimap::make_value(L'e', 5));
    c2.insert(Mymultimap::make_value(L'f', 6));
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[d 4] [e 5] [f 6]
[d 4] [e 5] [f 6]
[a 1] [b 2] [c 3]

`multimap::to_array`

Zkopíruje řízenou sekvenci do nového pole.

Syntaxe

cli::array<value_type>^ to_array();

Poznámky

Členová funkce vrátí matici obsahující řízenou sekvenci. Použijete ji k získání kopie řízené sekvence ve formuláři pole.

Příklad

// cliext_multimap_to_array.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // copy the container and modify it
    cli::array<Mymultimap::value_type>^ a1 = c1.to_array();

    c1.insert(Mymultimap::make_value(L'd', 4));
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (Mymultimap::value_type elem in a1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3]

`multimap::upper_bound`

Najde konec rozsahu, který odpovídá zadanému klíči.

Syntaxe

iterator upper_bound(key_type key);

Parametry

key
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Člen funkce určuje poslední prvek X v řízené sekvenci, který má ekvivalentní řazení na key. Pokud takový prvek neexistuje nebo je-li X posledním prvkem v řízené sekvenci, vrátí ; v opačném případě vrátí end()iterátor, který určuje první prvek nad rámec X. Slouží k vyhledání konce sekvence prvků aktuálně v řízené sekvenci, která odpovídá zadanému klíči.

Příklad

// cliext_multimap_upper_bound.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    Mymultimap::iterator it = c1.upper_bound(L'a');
    System::Console::WriteLine("*upper_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.upper_bound(L'b');
    System::Console::WriteLine("*upper_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
upper_bound(L'x')==end() = True
*upper_bound(L'a') = [b 2]
*upper_bound(L'b') = [c 3]

`multimap::value_comp`

Zkopíruje delegáta řazení pro dvě hodnoty prvků.

Syntaxe

value_compare^ value_comp();

Poznámky

Členová funkce vrátí delegáta řazení, který se používá k seřazení řízené sekvence. Použijete ho k porovnání dvou hodnot prvků.

Příklad

// cliext_multimap_value_comp.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    Mymultimap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Mymultimap::make_value(L'a', 1),
            Mymultimap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Mymultimap::make_value(L'a', 1),
            Mymultimap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Mymultimap::make_value(L'b', 2),
            Mymultimap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = False
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

`multimap::value_compare`

Delegát řazení pro dvě hodnoty prvků.

Syntaxe

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Poznámky

Typ je synonymem pro delegáta, který určuje pořadí argumentů jeho hodnoty.

Příklad

// cliext_multimap_value_compare.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    Mymultimap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Mymultimap::make_value(L'a', 1),
            Mymultimap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Mymultimap::make_value(L'a', 1),
            Mymultimap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Mymultimap::make_value(L'b', 2),
            Mymultimap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = False
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

`multimap::value_type`

Typ prvku

Syntaxe

typedef generic_value value_type;

Poznámky

Typ je synonymem pro generic_value.

Příklad

// cliext_multimap_value_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using value_type
    for (Mymultimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Mymultimap::value_type val = *it;
        System::Console::Write("[{0} {1}] ", val->first, val->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`operator!=` (multimap)

Porovnání seznamu se nerovná.

Syntaxe

template<typename Key,
    typename Mapped>
    bool operator!=(multimap<Key, Mapped>% left,
        multimap<Key, Mapped>% right);

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(left == right). Použijete ho k otestování, zda left není seřazeno stejně jako right když jsou dva multimapy porovnávány elementem.

Příklad

// cliext_multimap_operator_ne.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymultimap c2;
    c2.insert(Mymultimap::make_value(L'a', 1));
    c2.insert(Mymultimap::make_value(L'b', 2));
    c2.insert(Mymultimap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] != [a b c] is False
[a b c] != [a b d] is True

`operator<` (multimap)

Seznam je menší než porovnání.

Syntaxe

template<typename Key,
    typename Mapped>
    bool operator<(multimap<Key, Mapped>% left,
        multimap<Key, Mapped>% right);

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí hodnotu true if, pro nejnižší pozici i , pro kterou !(right[i] < left[i]) je také pravda left[i] < right[i]. V opačném případě se vrátí left->size() < right->size(). Použijete ho k otestování, zda left je seřazen před right , když jsou tyto dva multimapy porovnány elementem.

Příklad

// cliext_multimap_operator_lt.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymultimap c2;
    c2.insert(Mymultimap::make_value(L'a', 1));
    c2.insert(Mymultimap::make_value(L'b', 2));
    c2.insert(Mymultimap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (multimap)

Uveďte menší nebo rovno porovnání.

Syntaxe

template<typename Key,
    typename Mapped>
    bool operator<=(multimap<Key, Mapped>% left,
        multimap<Key, Mapped>% right);

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(right < left). Použijete ho k otestování, zda left není seřazen za right , když jsou tyto dva multimapy porovnávány elementem.

Příklad

// cliext_multimap_operator_le.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymultimap c2;
    c2.insert(Mymultimap::make_value(L'a', 1));
    c2.insert(Mymultimap::make_value(L'b', 2));
    c2.insert(Mymultimap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

`operator==` (multimap)

Porovnání se seznamem se rovná

Syntaxe

template<typename Key,
    typename Mapped>
    bool operator==(multimap<Key, Mapped>% left,
        multimap<Key, Mapped>% right);

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí hodnotu true pouze v případě, že sekvence řízené left a right mají stejnou délku a pro každou pozici i, left[i] == right[i]. Použijete ho k otestování, zda left je seřazeno stejně jako right když jsou dva multimapy porovnávány elementem.

Příklad

// cliext_multimap_operator_eq.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymultimap c2;
    c2.insert(Mymultimap::make_value(L'a', 1));
    c2.insert(Mymultimap::make_value(L'b', 2));
    c2.insert(Mymultimap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (multimap)

Seznam je větší než porovnání.

Syntaxe

template<typename Key,
    typename Mapped>
    bool operator>(multimap<Key, Mapped>% left,
        multimap<Key, Mapped>% right);

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí right < left. Použijete ho k otestování, zda left je seřazen po right , když jsou dva multimapy porovnávány elementem.

Příklad

// cliext_multimap_operator_gt.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymultimap c2;
    c2.insert(Mymultimap::make_value(L'a', 1));
    c2.insert(Mymultimap::make_value(L'b', 2));
    c2.insert(Mymultimap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (multimap)

Seznam větší než nebo rovno porovnání.

Syntaxe

template<typename Key,
    typename Mapped>
    bool operator>=(multimap<Key, Mapped>% left,
        multimap<Key, Mapped>% right);

Parametry

left
Levý kontejner, který chcete porovnat.

right
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(left < right). Použijete ho k otestování, zda left není seřazena před right tím, když jsou tyto dva multimapy porovnávány elementem.

Příklad

// cliext_multimap_operator_ge.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::multimap<wchar_t, int> Mymultimap;
int main()
    {
    Mymultimap c1;
    c1.insert(Mymultimap::make_value(L'a', 1));
    c1.insert(Mymultimap::make_value(L'b', 2));
    c1.insert(Mymultimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymultimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymultimap c2;
    c2.insert(Mymultimap::make_value(L'a', 1));
    c2.insert(Mymultimap::make_value(L'b', 2));
    c2.insert(Mymultimap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymultimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False

Sdílet prostřednictvím

multimap (STL/CLR)

Syntaxe

Parametry

Požadavky

Deklarace

Rozhraní

Poznámky

Členové

multimap::begin

Syntaxe

Poznámky

Příklad

multimap::clear

Syntaxe

Poznámky

Příklad

multimap::const_iterator

Syntaxe

Poznámky

Příklad

multimap::const_reference

Syntaxe

Poznámky

Příklad

multimap::const_reverse_iterator

Syntaxe

Poznámky

Příklad

multimap::count

Syntaxe

Parametry

Poznámky

Příklad

multimap::difference_type

Syntaxe

Poznámky

Příklad

multimap::empty

Syntaxe

Poznámky

Příklad

multimap::end

Syntaxe

Poznámky

Příklad

multimap::equal_range

Syntaxe

Parametry

Poznámky

Příklad

multimap::erase

Syntaxe

Parametry

Poznámky

Příklad

multimap::find

Syntaxe

Parametry

Poznámky

Příklad

multimap::generic_container

Syntaxe

Poznámky

Příklad

multimap::generic_iterator

Syntaxe

Poznámky

Příklad

multimap::generic_reverse_iterator

Syntaxe

Poznámky

Příklad

multimap::generic_value

Syntaxe

Poznámky

Příklad

multimap::insert

Syntaxe

Parametry

`multimap` (STL/CLR)

`multimap::begin`

`multimap::clear`

`multimap::const_iterator`

`multimap::const_reference`

`multimap::const_reverse_iterator`

`multimap::count`

`multimap::difference_type`

`multimap::empty`

`multimap::end`

`multimap::equal_range`

`multimap::erase`

`multimap::find`

`multimap::generic_container`

`multimap::generic_iterator`

`multimap::generic_reverse_iterator`

`multimap::generic_value`

`multimap::insert`

`multimap::iterator`

`multimap::key_comp`

`multimap::key_compare`

`multimap::key_type`

`multimap::lower_bound`

`multimap::make_value`

`multimap::mapped_type`

`multimap::multimap`

`multimap::operator=`

`multimap::rbegin`

`multimap::reference`

`multimap::rend`

`multimap::reverse_iterator`

`multimap::size`

`multimap::size_type`

`multimap::swap`