hash_multiset (STL/CLR)

Třída šablony popisuje objekt, který řídí různou délkovou sekvenci prvků, které mají obousměrný přístup. Kontejner slouží hash_multiset 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. Hodnota každého prvku se používá jako klíč pro řazení sekvence.

V následujícím GValue popisu je stejný jako GKey, který je zase stejný, jako Key pokud druhý typ odkazu, v takovém případě je Key^to .

Syntaxe

template<typename Key>
    ref class hash_multiset
        :   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.

Požadavky

Header:<cliext/hash_set>

Obor názvů:cliext

Deklarace

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

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

Operátor	Popis
hash_multiset::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 YX, ž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_set šablony (STL/CLR) objekt třídy hash_multiset š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 slouží jako klíč i hodnota. 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_multiset 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é hash_multiset::end. Pokud existuje, můžete tento iterátor dekrementovat, abyste dosáhli posledního prvku v řízené sekvenci. Můžete zvýšit hash_multiset 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_multiset přímo na jeho číselnou pozici. To vyžaduje iterátor náhodného přístupu.

hash_multiset Iterátor ukládá popisovač do přidruženého hash_multiset 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_multiset Iterátor zůstane platný, pokud je přidružený hash_multiset uzel přidružený k některým hash_multiset. 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_multiset::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_multiset_begin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_multiset::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

a b c
*begin() = a
*++begin() = b

hash_multiset::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_multiset_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    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 b c
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_multiset::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_multiset_clear.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

hash_multiset::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_multiset_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_multiset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::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_multiset_const_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_multiset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_multiset::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::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_multiset_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_multiset::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

hash_multiset::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_multiset_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    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 b c
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

hash_multiset::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_hash_multiset_difference_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

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

a b c
end()-begin() = 3
begin()-end() = -3

hash_multiset::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_multiset , jestli je prázdný.

Příklad

// cliext_hash_multiset_empty.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    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 b c
size() = 3
empty() = False
size() = 0
empty() = True

hash_multiset::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_multiset_end.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_multiset::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);
    return (0);
    }

a b c
*-- --end() = b
*--end() = c

hash_multiset::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_multiset_equal_range.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
typedef Myhash_multiset::pair_iter_iter Pairii;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    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} ", *pair1.first);
    System::Console::WriteLine();
    return (0);
    }

a b c
equal_range(L'x') empty = True
b

hash_multiset::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_hash_multiset_erase.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.insert(L'd');
    c1.insert(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    Myhash_multiset::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

hash_multiset::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í end(). Použijete ho k vyhledání prvku aktuálně v řízené sekvenci, která odpovídá zadanému klíči.

Příklad

// cliext_hash_multiset_find.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
find A = False
find b = b
find C = False

hash_multiset::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_multiset_generic_container.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(L'e');
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

hash_multiset::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_multiset_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
a b c
a

hash_multiset::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_multiset_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
a b c
c

hash_multiset::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_multiset_generic_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
a b c
a

hash_multiset::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_multiset_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::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_multiset::hash_multiset

Sestaví objekt kontejneru.

Syntaxe

hash_multiset();
explicit hash_multiset(key_compare^ pred);
hash_multiset(key_compare^ pred, hasher^ hashfn);
hash_multiset(hash_multiset<Key>% right);
hash_multiset(hash_multiset<Key>^ right);
template<typename InIter>
    hash_multiset(InIter first, InIter last);
template<typename InIter>
    hash_multiset(InIter first, InIter last,
        key_compare^ pred);
template<typename InIter>
    hash_multiset(InIter first, InIter last,
        key_compare^ pred, hasher^ hashfn);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);
hash_multiset(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_multiset();

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_multiset(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_multiset(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_multiset(hash_multiset<Key>% 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_multisetright, s výchozím pořadím predikát a hash funkce.

Konstruktor:

hash_multiset(hash_multiset<Key>^ 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_multisetright, s výchozím pořadím predikát a hash funkce.

Konstruktor:

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

inicializuje řízenou sekvenci [first, last), s výchozím predikátem řazení a s výchozí hash 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_multiset(InIter first, InIter last, key_compare^ pred);

inicializuje řízenou sekvenci [first, last), s pořadím predikát preda s výchozí hash 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_multiset(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

inicializuje řízenou sekvenci [first, last), s pořadím predikát preda s 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_multiset(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_multiset(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_multiset(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_multiset_construct.cpp
// compile with: /clr
#include <cliext/hash_set>

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

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

    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    c2.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    c2h.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_multiset c3(c1.begin(), c1.end());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

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

    // construct with an enumeration
    Myhash_multiset c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

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

    // construct from a generic container
    Myhash_multiset c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Myhash_multiset c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
a b c
size() = 0
a b c
size() = 0
c b a

a b c
a b c
c b a

a b c
a b c
c b a

a b c
a b c

hash_multiset::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_multiset_hasher.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::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_multiset::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_hash_multiset_insert.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    System::Console::WriteLine("insert(L'x') = {0}",
        *c1.insert(L'x'));

    System::Console::WriteLine("insert(L'b') = {0}",
        *c1.insert(L'b'));

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value with hint
    System::Console::WriteLine("insert(begin(), L'y') = {0}",
        *c1.insert(c1.begin(), L'y'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_multiset c2;
    Myhash_multiset::iterator it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_multiset c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(L'x') = x
insert(L'b') = b
a b b c x
insert(begin(), L'y') = y
a b b c x y
a b b c x
a b b c x y

hash_multiset::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_multiset_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_multiset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::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_multiset_key_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::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_multiset 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_multiset::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_multiset_key_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::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_multiset 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_multiset::key_type

Typ klíče řazení

Syntaxe

typedef Key key_type;

Poznámky

Typ je synonymem pro parametr Keyšablony .

Příklad

// cliext_hash_multiset_key_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using key_type
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_multiset::key_type val = *it;

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

a b c

hash_multiset::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() / count(). Použijete ho k určení průměrné velikosti kbelíku.

Příklad

// cliext_hash_multiset_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    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 b c
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_multiset::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í 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_multiset_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    System::Console::WriteLine("*lower_bound(L'a') = {0}",
        *c1.lower_bound(L'a'));
    System::Console::WriteLine("*lower_bound(L'b') = {0}",
        *c1.lower_bound(L'b'));
    return (0);
    }

a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b

hash_multiset::make_value

Vytvoří objekt hodnoty.

Syntaxe

static value_type make_value(key_type key);

Parametry

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

Poznámky

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

Příklad

// cliext_hash_multiset_make_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(Myhash_multiset::make_value(L'a'));
    c1.insert(Myhash_multiset::make_value(L'b'));
    c1.insert(Myhash_multiset::make_value(L'c'));

    // display contents " a b c"
    for each (Myhash_multiset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::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_multiset_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    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 b c
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_multiset::operator=

Nahradí řízenou sekvenci.

Syntaxe

hash_multiset<Key>% operator=(hash_multiset<Key>% 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_multiset_operator_as.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (Myhash_multiset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_multiset c2;
    c2 = c1;
// display contents " a b c"
    for each (Myhash_multiset::value_type elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

hash_multiset::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_multiset_rbegin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_multiset::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b

hash_multiset::reference

Typ odkazu na prvek

Syntaxe

typedef value_type% reference;

Poznámky

Typ popisuje odkaz na prvek.

Příklad

// cliext_hash_multiset_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_multiset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_multiset::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::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_multiset_rehash.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    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 b c
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_multiset::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_multiset_rend.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_multiset::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a

hash_multiset::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_multiset_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_multiset::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a

hash_multiset::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_multiset::emptyna .

Příklad

// cliext_hash_multiset_size.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

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

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

hash_multiset::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_multiset_size_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
end()-begin() = 3

hash_multiset::swap

Zamění obsah dvou kontejnerů.

Syntaxe

void swap(hash_multiset<Key>% 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_multiset_swap.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_multiset c2;
    c2.insert(L'd');
    c2.insert(L'e');
    c2.insert(L'f');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
d e f
d e f
a b c

hash_multiset::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_multiset_to_array.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

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

    c1.insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

hash_multiset::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í 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_multiset_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    System::Console::WriteLine("*upper_bound(L'a') = {0}",
        *c1.upper_bound(L'a'));
    System::Console::WriteLine("*upper_bound(L'b') = {0}",
        *c1.upper_bound(L'b'));
    return (0);
    }

a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c

hash_multiset::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_multiset_value_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::value_compare^ kcomp = c1.value_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();
    return (0);
    }

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

hash_multiset::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_multiset_value_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::value_compare^ kcomp = c1.value_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();
    return (0);
    }

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

hash_multiset::value_type

Typ prvku

Syntaxe

typedef generic_value value_type;

Poznámky

Typ je synonymem pro generic_value.

Příklad

// cliext_hash_multiset_value_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using value_type
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_multiset::value_type val = *it;

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

a b c