Sdílet prostřednictvím


hash_multimap (STL/CLR)

Třída šablony popisuje objekt, který řídí různou délkovou sekvenci prvků, které mají obousměrný přístup. Kontejner slouží hash_multimap ke správě posloupnosti prvků jako tabulky hash, přičemž každá položka tabulky ukládá obousměrný propojený seznam uzlů a každý uzel, který 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 hash_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::IHash<Gkey, GValue>
    { ..... };

Parametry

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

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

Požadavky

Header:<cliext/hash_map>

Obor názvů: cliext

Deklarace

Definice typu Popis
hash_multimap::const_iterator Typ konstantního iterátoru řízené sekvence
hash_multimap::const_reference Typ konstantního odkazu na prvek
hash_multimap::const_reverse_iterator Typ konstantního zpětného iterátoru pro řízenou sekvenci.
hash_multimap::difference_type Typ (pravděpodobně podepsané) vzdálenosti mezi dvěma prvky.
hash_multimap::generic_container Typ obecného rozhraní pro kontejner.
hash_multimap::generic_iterator Typ iterátoru pro obecné rozhraní kontejneru.
hash_multimap::generic_reverse_iterator Typ zpětného iterátoru pro obecné rozhraní kontejneru.
hash_multimap::generic_value Typ elementu pro obecné rozhraní kontejneru.
hash_multimap::hasher Delegování hash pro klíč
hash_multimap::iterator Typ iterátoru řízené sekvence
hash_multimap::key_compare Pořadí delegátů pro dva klíče.
hash_multimap::key_type Typ klíče řazení
hash_multimap::mapped_type Typ mapované hodnoty přidružené ke každému klíči.
hash_multimap::reference Typ odkazu na prvek
hash_multimap::reverse_iterator Typ zpětné iterátoru pro řízenou sekvenci.
hash_multimap::size_type Typ (nezáporné) vzdálenosti mezi dvěma prvky.
hash_multimap::value_compare Delegát řazení pro dvě hodnoty prvků.
hash_multimap::value_type Typ prvku
Členová funkce Popis
hash_multimap::begin Určuje začátek řízené sekvence.
hash_multimap::bucket_count Spočítá počet kbelíků.
hash_multimap::clear Odebere všechny prvky.
hash_multimap::count Počítá prvky odpovídající zadanému klíči.
hash_multimap::empty Zkouší, zda nejsou přítomny žádné prvky.
hash_multimap::end Určuje konec řízené sekvence.
hash_multimap::equal_range Najde rozsah, který odpovídá zadanému klíči.
hash_multimap::erase Odebere prvky v určených pozicích.
hash_multimap::find Vyhledá prvek, který odpovídá zadanému klíči.
hash_multimap::hash_delegate Zkopíruje delegování hash pro klíč.
hash_multimap::hash_multimap Sestaví objekt kontejneru.
hash_multimap::insert Přidá prvky.
hash_multimap::key_comp Zkopíruje delegáta řazení pro dva klíče.
hash_multimap::load_factor Spočítá průměrný počet prvků na kbelík.
hash_multimap::lower_bound Najde začátek rozsahu, který odpovídá zadanému klíči.
hash_multimap::make_value Vytvoří objekt hodnoty.
hash_multimap::max_load_factor Získá nebo nastaví maximální počet prvků na kbelík.
hash_multimap::rbegin Určuje začátek obrácené řízené sekvence.
hash_multimap::rehash Znovu vytvoří hashovací tabulku.
hash_multimap::rend Určuje konec obrácené řízené sekvence.
hash_multimap::size Spočítá počet prvků.
hash_multimap::swap Zamění obsah dvou kontejnerů.
hash_multimap::to_array Zkopíruje řízenou sekvenci do nového pole.
hash_multimap::upper_bound Najde konec rozsahu, který odpovídá zadanému klíči.
hash_multimap::value_comp Zkopíruje delegáta řazení pro dvě hodnoty prvků.
Operátor Popis
hash_multimap::operator= Nahradí řízenou sekvenci.

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ů.
IHash<Key, Value> Udržujte obecný kontejner.

Poznámky

Objekt přidělí a uvolní úložiště pro sekvenci, která řídí jako jednotlivé uzly v obousměrném propojeném seznamu. Aby se urychlil přístup, objekt také udržuje různou délku pole ukazatelů do seznamu (tabulka hash), efektivně spravuje celý seznam jako posloupnost dílčích seznamů nebo kbelíků. Vloží prvky do kbelíku, který udržuje seřazený tak, že mění propojení 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á jednotlivé kontejnery, které řídí voláním uloženého delegáta objekt typu hash_set::key_compare. Při vytváření hash_set 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 uloženému objektu delegáta přistupujete voláním členské funkce hash_set::key_comp. Takový objekt delegáta musí definovat ekvivalentní řazení mezi klíči typu hash_set::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) && key_comp()(Y, X) je pravda, znamená to Y X, že mají ekvivalentní řazení.

Jakékoli pravidlo řazení, které se chová jako operator<=(key_type, key_type), operator>=(key_type, key_type) nebo operator==(key_type, key_type) definuje ekvivalentní řazení.

Kontejner zajišťuje pouze to, že prvky, jejichž klíče mají ekvivalentní řazení (a která hodnota hash se stejnou celočíselnou hodnotou) sousedí v rámci kontejneru. Na rozdíl od třídy hash_map šablony (STL/CLR) objekt třídy hash_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í.)

Objekt určuje, který kontejner by měl obsahovat daný klíč řazení voláním uloženého delegáta objekt typu hash_set::hasher. K tomuto uloženému objektu přistupujete voláním členské funkce hash_set::hash_delegate k získání celočíselné hodnoty, která závisí na hodnotě klíče. Při vytváření hash_set můžete určit uložený objekt delegáta; pokud zadáte žádný objekt delegáta, výchozí je funkce System::Object::hash_value(key_type). To znamená, že pro všechny klíče X a Y:

hash_delegate()(X) vrátí stejný celočíselnou výsledek pro každé volání.

Pokud X a Y mají ekvivalentní řazení, hash_delegate()(X) měl by vrátit stejný celočíselnou výsledek jako hash_delegate()(Y).

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 konstantním čase. To znamená, že počet operací je nezávislý na počtu prvků v sekvenci, alespoň v nejlepším případě. Vložení prvku navíc zneplatní žádné iterátory a odebrání prvku zneplatní pouze iterátory, které ukazují na odebraný prvek.

Pokud nejsou hodnoty hash rovnoměrně distribuované, může se však degenerovat tabulka hash. V extrémních hodnotách (pro funkci hash, která vždy vrací stejnou hodnotu), vyhledávání, vložení a odebrání jsou úměrné počtu prvků v sekvenci (lineární čas). Kontejner se snaží zvolit rozumnou hashovací funkci, střední velikost kbelíku a velikost hash-table (celkový počet kbelíků), ale můžete přepsat libovolnou nebo všechny tyto volby. Viz například funkce hash_set::max_load_factor a hash_set::rehash.

Podporuje hash_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 hash_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 hash_multimap přímo na jeho číselnou pozici. To vyžaduje iterátor náhodného přístupu.

hash_multimap Iterátor ukládá popisovač do přidruženého hash_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. hash_multimap Iterátor zůstane platný, pokud je přidružený hash_multimap uzel přidružený k některým hash_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é

hash_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_hash_multimap_begin.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // inspect first two items
    Myhash_multimap::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]

hash_multimap::bucket_count

Spočítá počet kbelíků.

Syntaxe

int bucket_count();

Poznámky

Členová funkce vrátí aktuální počet kbelíků. Použijete ji k určení velikosti tabulky hash.

Příklad

// cliext_hash_multimap_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_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_hash_multimap_clear.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Myhash_multimap::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

hash_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_hash_multimap_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::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]

hash_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_hash_multimap_const_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

hash_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_hash_multimap_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_multimap::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]

hash_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_hash_multimap_count.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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

hash_multimap::d ifference_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_hash_multimap_difference_type.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

    // compute negative difference
    diff = 0;
    for (Myhash_multimap::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

hash_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í hash_multimap , jestli je prázdný.

Příklad

// cliext_hash_multimap_empty.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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

hash_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_hash_multimap_end.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // inspect last two items
    Myhash_multimap::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]

hash_multimap::equal_range

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

Syntaxe

cliext::pair<iterator, iterator> equal_range(key_type key);

Parametry

key
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Členová funkce vrátí dvojici iterátorů cliext::pair<iterator, iterator>(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_hash_multimap_equal_range.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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]

hash_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 polootevřené oblasti [first, last)a vrátí iterátor, který určuje první prvek, který zůstává nad všemi odebranými prvky, 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_hash_multimap_erase.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::hash_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::hash_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::hash_multimap<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::hash_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

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

Příklad

// cliext_hash_multimap_find.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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());

    Myhash_multimap::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

hash_multimap::generic_container

Typ obecného rozhraní pro kontejner.

Syntaxe

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

Poznámky

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

Příklad

// cliext_hash_multimap_generic_container.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

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

    // modify original and display generic
    c1.insert(Myhash_multimap::make_value(L'e', 5));
    for each (Myhash_multimap::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]

hash_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_hash_multimap_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

    // get an element and display it
    Myhash_multimap::generic_iterator gcit = gc1->begin();
    Myhash_multimap::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]

hash_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_hash_multimap_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

    // get an element and display it
    Myhash_multimap::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_multimap::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]

hash_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_hash_multimap_generic_value.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

    // get an element and display it
    Myhash_multimap::generic_iterator gcit = gc1->begin();
    Myhash_multimap::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]

hash_multimap::hash_delegate

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

Syntaxe

hasher^ hash_delegate();

Poznámky

Členová funkce vrátí delegáta, který se používá k převodu hodnoty klíče na celé číslo. Použijete ho k zatřiďovacímu klíči.

Příklad

// cliext_hash_multimap_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }
hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_multimap::hash_multimap

Sestaví objekt kontejneru.

Syntaxe

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

Parametry

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

hashfn
Funkce hash pro mapování klíčů na kontejnery

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:

hash_multimap();

inicializuje řízenou sekvenci bez prvků, s výchozím predikátem key_compare()řazení a s výchozí hash funkcí. Použijete ji k určení prázdné počáteční řízené sekvence s výchozí predikátem řazení a hash funkce.

Konstruktor:

explicit hash_multimap(key_compare^ pred);

inicializuje řízenou sekvenci bez prvků, s predikátem predřazení a s výchozí hashovací funkcí. Slouží k určení prázdné počáteční řízené sekvence se zadaným predikátem řazení a výchozí hashovací funkcí.

Konstruktor:

hash_multimap(key_compare^ pred, hasher^ hashfn);

inicializuje řízenou sekvenci bez prvků, s pořadím predikát preda s hash funkce hashfn. Slouží k určení prázdné počáteční řízené sekvence se zadanou predikátem řazení a hashovou funkcí.

Konstruktor:

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

inicializuje řízenou sekvenci [right.begin(), right.end()), s výchozím predikátem řazení a s výchozí hash funkcí. Použijete ji k určení počáteční řízené sekvence, která je kopií sekvence řízené objektem hash_multimap right, s výchozím pořadím predikát a hash funkce.

Konstruktor:

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

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

Konstruktor:

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

inicializuje řízenou sekvenci se sekvencí [first, last), s výchozím predikátem řazení a s výchozí hashovací funkcí. Použijete ji k tomu, aby řízená sekvence byla kopií jiné sekvence s výchozí predikátem řazení a hash funkcí.

Konstruktor:

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

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

Konstruktor:

template<typename InIter> hash_multimap(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

inicializuje řízenou sekvenci se sekvencí [first, last), s predikátem predřazení a pomocí hash funkce hashfn. Použijete ji k tomu, aby řízená sekvence byla kopií jiné sekvence se zadanou predikátem řazení a funkcí hash.

Konstruktor:

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

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

Konstruktor:

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

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

Konstruktor:

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

inicializuje řízenou sekvenci sekvencí určenou enumerátorem right, s pořadím predikátu pred, a s hash funkce hashfn. Použijete ho k tomu, aby řízená sekvence byla kopií jiné sekvence popsané enumerátorem se zadanou predikátem řazení a funkcí hash.

Příklad

// cliext_hash_multimap_construct.cpp
// compile with: /clr
#include <cliext/hash_map>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

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

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

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

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

    // construct with an ordering rule and hash function
    Myhash_multimap c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multimap::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

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

    // construct with an iterator range
    Myhash_multimap c3(c1.begin(), c1.end());
    for each (Myhash_multimap::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
    Myhash_multimap c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (Myhash_multimap::value_type elem in c4)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

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

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

    // construct by copying a container handle
    Myhash_multimap c8(%c3);
    for each (Myhash_multimap::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
[a 1] [b 2] [c 3]
size() = 0
[c 3] [b 2] [a 1]

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

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

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

hash_multimap::hasher

Delegování hash pro klíč

Syntaxe

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

Poznámky

Typ popisuje delegáta, který převede hodnotu klíče na celé číslo.

Příklad

// cliext_hash_multimap_hasher.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }
hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_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í člen 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_hash_multimap_insert.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

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

    for each (Myhash_multimap::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(), Myhash_multimap::make_value(L'y', 25));
    System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
        it->first, it->second);
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    // insert an enumeration
    Myhash_multimap c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Myhash_multimap::value_type>^)%c1);
    for each (Myhash_multimap::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]

hash_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_hash_multimap_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::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]

hash_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_hash_multimap_key_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::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
    Myhash_multimap 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') = True
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

hash_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_hash_multimap_key_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::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
    Myhash_multimap 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') = True
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

hash_multimap::key_type

Typ klíče řazení

Syntaxe

typedef Key key_type;

Poznámky

Typ je synonymem pro parametr Keyšablony .

Příklad

// cliext_hash_multimap_key_type.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

hash_multimap::load_factor

Spočítá průměrný počet prvků na kbelík.

Syntaxe

float load_factor();

Poznámky

Členová funkce vrátí (float)size() / bucket_count(). Použijete ho k určení průměrné velikosti kbelíku.

Příklad

// cliext_hash_multimap_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_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á hashuje do stejného kbelíku jako key a má ekvivalentní řazení .key Pokud takový prvek neexistuje, vrátí hash_multimap::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_hash_multimap_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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());

    Myhash_multimap::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]

hash_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_hash_multimap_make_value.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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]

hash_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_hash_multimap_mapped_type.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

hash_multimap::max_load_factor

Získá nebo nastaví maximální počet prvků na kbelík.

Syntaxe

float max_load_factor();
void max_load_factor(float new_factor);

Parametry

new_factor
Nový maximální zátěžový faktor pro uložení

Poznámky

První členová funkce vrátí aktuální uložený maximální zátěžový faktor. Použijete ho k určení maximální průměrné velikosti kbelíku.

Druhá členová funkce nahrazuje maximální zátěžový faktor úložiště znakem new_factor. K automatickému přemísnění nedojde až do následného vložení.

Příklad

// cliext_hash_multimap_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_multimap::operator=

Nahradí řízenou sekvenci.

Syntaxe

hash_multimap<Key, Mapped>% operator=(hash_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_hash_multimap_operator_as.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // assign to a new container
    Myhash_multimap c2;
    c2 = c1;
// display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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]

hash_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_hash_multimap_rbegin.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // inspect first two items in reversed sequence
    Myhash_multimap::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]

hash_multimap::reference

Typ odkazu na prvek

Syntaxe

typedef value_type% reference;

Poznámky

Typ popisuje odkaz na prvek.

Příklad

// cliext_hash_multimap_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

hash_multimap::rehash

Znovu vytvoří hashovací tabulku.

Syntaxe

void rehash();

Poznámky

Členová funkce znovu sestaví tabulku hash a zajistí, že load_factor() <= max_load_factor(). V opačném případě se tabulka hash po vložení zvětšuje pouze podle potřeby. (Nikdy se automaticky nezmenšuje velikost.) Použijete ho k úpravě velikosti tabulky hash.

Příklad

// cliext_hash_multimap_rehash.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_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_hash_multimap_rend.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // inspect first two items in reversed sequence
    Myhash_multimap::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]

hash_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_hash_multimap_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_multimap::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]

hash_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 hash_multimap::empty()na .

Příklad

// cliext_hash_multimap_size.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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(Myhash_multimap::make_value(L'd', 4));
    c1.insert(Myhash_multimap::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

hash_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_hash_multimap_size_type.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    // compute positive difference
    Myhash_multimap::size_type diff = 0;
    for (Myhash_multimap::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

hash_multimap::swap

Zamění obsah dvou kontejnerů.

Syntaxe

void swap(hash_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_hash_multimap_swap.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

    for each (Myhash_multimap::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]

hash_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_hash_multimap_to_array.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

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

    // display the earlier array copy
    for each (Myhash_multimap::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]

hash_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á hashuje do stejného kbelíku jako key a má ekvivalentní řazení .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í hash_multimap::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_hash_multimap_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::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());

    Myhash_multimap::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]

hash_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_hash_multimap_value_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

hash_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_hash_multimap_value_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

hash_multimap::value_type

Typ prvku

Syntaxe

typedef generic_value value_type;

Poznámky

Typ je synonymem pro generic_value.

Příklad

// cliext_hash_multimap_value_type.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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