unordered_multiset – třída

Článek
10/12/2023

Šablona třídy popisuje objekt, který řídí různou délkovou sekvenci prvků typu const Key. Sekvence je slabě seřazená podle funkce hash, která sekvenci rozděluje do uspořádané sady dílčích sekvencí, které se nazývají kbelíky. V rámci každého kbelíku funkce porovnání určuje, zda má nějaká dvojice prvků odpovídající řazení. Každý prvek slouží jako klíč řazení i hodnota. Sekvence je reprezentována způsobem, který umožňuje vyhledat, vložit a odebrat libovolný prvek s několika operacemi, které mohou být nezávislé na počtu prvků v sekvenci (konstantní čas), alespoň pokud všechny kbelíky mají přibližně stejnou délku. V nejhorším případě platí, že když jsou všechny prvky v jednom kbelíku, je počet operací úměrný počtu prvků v sekvenci (lineární čas). Vkládání prvků navíc nezruší platnost žádných iterátorů a odstranění prvku zruší platnost pouze těch iterátorů, které odkazují na odstraněný prvek.

Syntaxe

template <class Key,
    class Hash = std::hash<Key>,
    class Pred = std::equal_to<Key>,
    class Alloc = std::allocator<Key>>
class unordered_multiset;

Parametry

Klíč
Klíčový typ

Hash
Typ objektu hashovací funkce

Před
Typ objektu funkce porovnání rovnosti

Aloka
Třída alokátoru

Členové

Definice typu	Popis
allocator_type	Typ alokátoru pro správu úložiště
const_iterator	Typ konstantního iterátoru řízené sekvence
const_local_iterator	Typ konstantního iterátoru kbelíku řízené sekvence
const_pointer	Typ konstantního ukazatele na prvek
const_reference	Typ konstantního odkazu na prvek
difference_type	Typ vzdálenosti se znaménkem mezi dvěma prvky
Hasher	Typ hashovací funkce
iterátor	Typ iterátoru řízené sekvence
key_equal	Typ funkce porovnání
key_type	Typ klíče řazení
local_iterator	Typ iterátoru kbelíku řízené sekvence
ukazatel	Typ ukazatele na prvek
odkaz	Typ odkazu na prvek
size_type	Typ vzdálenosti bez znaménka mezi dvěma prvky
value_type	Typ prvku

Členská funkce	Popis
začít	Určuje začátek řízené sekvence.
kbelík	Získá číslo kbelíku pro hodnotu klíče.
bucket_count	Získá počet kbelíků.
bucket_size	Získá velikost kbelíku.
cbegin	Určuje začátek řízené sekvence.
cend	Určuje konec řízené sekvence.
jasný	Odebere všechny prvky.
obsahuje^C++20	Zkontroluje, jestli existuje prvek se zadaným klíčem.
count	Zjistí počet prvků odpovídající zadanému klíči.
umístit	Přidá prvek vytvořený v místě.
emplace_hint	Přidá prvek vytvořený v místě s nápovědou.
empty	Zkouší, zda nejsou přítomny žádné prvky.
konec	Určuje konec řízené sekvence.
equal_range	Najde rozsah, který odpovídá zadanému klíči.
vymazat	Odebere prvky v určených pozicích.
find	Vyhledá prvek, který odpovídá zadanému klíči.
get_allocator	Získá uložený objekt alokátoru.
hash_function	Získá uložený objekt hashovací funkce.
vložit	Přidá prvky.
key_eq	Získá uložený objekt funkce porovnání.
load_factor	Spočítá průměrný počet prvků na kbelík.
max_bucket_count	Získá maximální počet kbelíků.
max_load_factor	Získá nebo nastaví maximální počet prvků na kbelík.
max_size	Získá maximální velikost řízené sekvence.
předělávka	Znovu vytvoří hashovací tabulku.
velikost	Spočítá počet prvků.
vyměnit	Zamění obsah dvou kontejnerů.
unordered_multiset	Sestaví objekt kontejneru.

Operátor	Popis
unordered_multiset::operator=	Zkopíruje tabulku hash.

Poznámky

Objekt pořadí, které řídí voláním dvou uložených objektů, objekt funkce porovnání typu unordered_multiset::key_equal a objekt funkce hash typu unordered_multiset::hasher. K prvnímu uloženému objektu se dostanete voláním členské funkce unordered_multiset::key_eq(); a k druhému uloženému objektu se dostanete voláním členské funkce unordered_multiset::hash_function(). Konkrétně pro všechny hodnoty a typ volání vrátí hodnotu true pouze v případě, že dvě hodnoty argumentu mají ekvivalentní pořadí; volání hash_function()(keyval) vrátí rozdělení hodnot typu size_t.key_eq()(X, Y) KeyY X Na rozdíl od šablony třídy unordered_set Třída, objekt typu unordered_multiset nezajistí, že key_eq()(X, Y) je vždy false pro všechny dva prvky řízené sekvence. (Klíče nemusí být jedinečné.)

Objekt také uchovává faktor maximálního zatížení, který určuje maximální požadovaný průměrný počet prvků na kbelík. Pokud vložení prvku způsobí , že unordered_multiset::load_factor() překročí maximální zátěžový faktor, kontejner podle potřeby zvýší počet kontejnerů a podle potřeby znovu sestaví tabulku hash.

Skutečné pořadí prvků v řízené sekvenci závisí na hashovací funkci, funkci porovnání, pořadí vkládání, faktoru maximálního zatížení a aktuálním počtu kbelíků. Pořadí prvků v řízené sekvenci obecně nelze předvídat. Můžete si však vždy být jisti, že všechny dílčí množiny prvků, které mají ekvivalentní řazení, v řízené sekvenci sousedí.

Objekt přidělí a uvolní úložiště pro sekvenci, která řídí prostřednictvím uloženého objektu alokátoru typu unordered_multiset::allocator_type. Takový objekt alokátoru musí mít stejné externí rozhraní jako objekt typu allocator. Všimněte si, že uložený objekt alokátoru není zkopírován při přiřazení objektu kontejneru.

Požadavky

Header:<unordered_set>

Namespace: std

unordered_multiset::allocator_type

Typ alokátoru pro správu úložiště

typedef Alloc allocator_type;

Poznámky

Typ je synonymem pro parametr Allocšablony .

Příklad

// std__unordered_set__unordered_multiset_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}

al == std::allocator() is true

unordered_multiset::begin

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

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parametry

nbucket
Číslo kbelíku.

Poznámky

První dvě členské funkce vrátí dopředný iterátor, který odkazuje na první prvek sekvence (nebo těsně za koncem prázdné sekvence). Poslední dvě členské funkce vrátí dopředný iterátor, který odkazuje na první prvek kontejneru nbucket (nebo těsně za koncem prázdného kontejneru).

Příklad

// std__unordered_set__unordered_multiset_begin.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect first two items "[c] [b]"
    Myset::iterator it2 = c1.begin();
    std::cout << "[" << *it2 << "] ";
    ++it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[c] [b]
[a]

unordered_multiset::bucket

Získá číslo kbelíku pro hodnotu klíče.

size_type bucket(const Key& keyval) const;

Parametry

keyval
Hodnota klíče, která se má mapovat.

Poznámky

Členová funkce vrátí číslo kbelíku, které aktuálně odpovídá hodnotě keyvalklíče .

Příklad

// std__unordered_set__unordered_multiset_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
}

[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset::bucket_count

Získá počet kbelíků.

size_type bucket_count() const;

Poznámky

Členová funkce vrátí aktuální počet kbelíků.

Příklad

// std__unordered_set__unordered_multiset_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::bucket_size

Získá velikost kontejneru.

size_type bucket_size(size_type nbucket) const;

Parametry

nbucket
Číslo kbelíku.

Poznámky

Členské funkce vrátí velikost kontejneru nbucket.

Příklad

// std__unordered_set__unordered_multiset_bucket_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
}

[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset::cbegin

const Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Návratová hodnota

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

Poznámky

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

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

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

auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator

unordered_multiset::cend

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

const_iterator cend() const;

Návratová hodnota

const Iterátor s přístupem vpřed, který odkazuje těsně nad konec rozsahu.

Poznámky

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

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

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

auto i2 = Container.cend();
// i2 is Container<T>::const_iterator

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

unordered_multiset::clear

Odebere všechny prvky.

void clear();

Poznámky

Členské funkce volá unordered_multiset::erase( unordered_multiset::begin(), unordered_multiset::end.())

Příklad

// std__unordered_set__unordered_multiset_clear.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::const_iterator

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

typedef T1 const_iterator;

Poznámky

Typ popisuje objekt, který může sloužit jako konstantní iterátor dopředu pro řízenou sekvenci. Zde je popsán jako synonymum pro typ T1definovaný implementací .

Příklad

// std__unordered_set__unordered_multiset_const_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::const_local_iterator

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

typedef T5 const_local_iterator;

Poznámky

Typ popisuje objekt, který může sloužit jako konstantní iterátor pro kontejner. Zde je popsán jako synonymum pro typ T5definovaný implementací .

Příklad

// std__unordered_set__unordered_multiset_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

unordered_multiset::const_pointer

Typ konstantního ukazatele na prvek

typedef Alloc::const_pointer const_pointer;

Poznámky

Typ popisuje objekt, který může sloužit jako konstantní ukazatel na prvek řízené sekvence.

Příklad

// std__unordered_set__unordered_multiset_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::const_pointer p = &*it;
        std::cout << "[" << *p << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::const_reference

Typ konstantního odkazu na prvek

typedef Alloc::const_reference const_reference;

Poznámky

Typ popisuje objekt, který může sloužit jako konstantní odkaz na prvek řízené sekvence.

Příklad

// std__unordered_set__unordered_multiset_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::const_reference ref = *it;
        std::cout << "[" << ref << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::contains

Zkontroluje, jestli existuje prvek se zadaným klíčem v objektu unordered_multiset.

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

Parametry

K
Typ klíče.

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

Návratová hodnota

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

Poznámky

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

template<class K> bool contains(const K& key) const Pouze se účastní řešení přetížení, pokud key_compare je transparentní.

Příklad

// Requires /std:c++20 or /std:c++latest
#include <unordered_set>
#include <iostream>

int main()
{
    std::unordered_multiset<int> theUnorderedMultiset = { 1, 2, 3 };

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

    return 0;
}

true
false

unordered_multiset::count

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

size_type count(const Key& keyval) const;

Parametry

keyval
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Členová funkce vrátí počet prvků v oblasti oddělené unordered_multiset::equal_range(keyval).

Příklad

// std__unordered_set__unordered_multiset_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "count('A') == " << c1.count('A') << std::endl;
    std::cout << "count('b') == " << c1.count('b') << std::endl;
    std::cout << "count('C') == " << c1.count('C') << std::endl;

    return (0);
}

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

unordered_multiset::d ifference_type

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

typedef T3 difference_type;

Poznámky

Typ signed integer popisuje objekt, který může představovat rozdíl mezi adresami libovolných dvou prvků v řízené sekvenci. Zde je popsán jako synonymum pro typ T3definovaný implementací .

Příklad

// std__unordered_set__unordered_multiset_difference_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // compute positive difference
    Myset::difference_type diff = 0;
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        ++diff;
    std::cout << "end()-begin() == " << diff << std::endl;

    // compute negative difference
    diff = 0;
    for (Myset::const_iterator it = c1.end();
        it != c1.begin(); --it)
        --diff;
    std::cout << "begin()-end() == " << diff << std::endl;

    return (0);
}

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

unordered_multiset::emplace

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

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

Parametry

args
Argumenty přeposílané k vytvoření prvku, který se má vložit do unordered_multiset.

Návratová hodnota

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

Poznámky

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

Pokud během vložení dojde k vyvolání výjimky, ale nedojde k tomu ve funkci hash kontejneru, kontejner se nezmění. Pokud je vyvolána výjimka ve funkci hash, výsledek není definován.

Příklad kódu najdete v tématu multiset::emplace.

unordered_multiset::emplace_hint

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

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

Parametry

args
Argumenty přeposílané k vytvoření prvku, který se má vložit do unordered_multiset.

kde
Nápověda týkající se místa, kde můžete začít hledat správný bod vložení.

Návratová hodnota

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

Poznámky

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

Pokud během vložení dojde k vyvolání výjimky, ale nedojde k tomu ve funkci hash kontejneru, kontejner se nezmění. Pokud je vyvolána výjimka ve funkci hash, výsledek není definován.

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

unordered_multiset::empty

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

bool empty() const;

Poznámky

Členová funkce vrátí hodnotu true pro prázdnou řízenou sekvenci.

Příklad

// std__unordered_set__unordered_multiset_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::end

Určuje konec řízené sekvence.

iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;

Parametry

nbucket
Číslo kbelíku.

Poznámky

První dvě členské funkce vrátí dopředný iterátor, který odkazuje těsně za koncem sekvence. Poslední dvě členské funkce vrátí dopředný iterátor, který odkazuje těsně za koncem kontejneru nbucket.

Příklad

// std__unordered_set__unordered_multiset_end.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect last two items "[a] [b]"
    Myset::iterator it2 = c1.end();
    --it2;
    std::cout << "[" << *it2 << "] ";
    --it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.end(c1.bucket('a'));
    --lit;
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a] [b]
[a]

unordered_multiset::equal_range

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

std::pair<iterator, iterator>
    equal_range(const Key& keyval);

std::pair<const_iterator, const_iterator>
    equal_range(const Key& keyval) const;

Parametry

keyval
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Členová funkce vrátí dvojici iterátorů X tak, aby [X.first, X.second) oddělovaly pouze ty prvky řízené sekvence, které mají ekvivalentní řazení s keyval. Pokud žádné takové prvky neexistují, jsou oba iterátory end().

Příklad

// std__unordered_set__unordered_multiset_equal_range.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display results of failed search
    std::pair<Myset::iterator, Myset::iterator> pair1 =
        c1.equal_range('x');
    std::cout << "equal_range('x'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    // display results of successful search
    pair1 = c1.equal_range('b');
    std::cout << "equal_range('b'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]

unordered_multiset::erase

Odebere prvek nebo rozsah prvků v unordered_multiset ze zadaných pozic nebo odebere prvky, které odpovídají zadanému klíči.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametry

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

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

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

Klíč
Hodnota klíče prvků, které mají být odebrány.

Návratová hodnota

Pro první dvě členské funkce, obousměrný iterátor, který určuje první prvek, který zůstává nad všemi odebranými prvky, nebo prvek, který je koncem unordered_multiset pokud žádný takový prvek neexistuje.

U třetí členské funkce vrátí počet prvků odebraných z unordered_multiset.

Poznámky

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

unordered_multiset::find

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

const_iterator find(const Key& keyval) const;

Parametry

keyval
Hodnota klíče, kterou chcete vyhledat.

Poznámky

Členová funkce vrátí unordered_multiset::equal_range(keyval).first.

Příklad

// std__unordered_set__unordered_multiset_find.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // try to find and fail
    std::cout << "find('A') == "
        << std::boolalpha << (c1.find('A') != c1.end()) << std::endl;

    // try to find and succeed
    Myset::iterator it = c1.find('b');
    std::cout << "find('b') == "
        << std::boolalpha << (it != c1.end())
        << ": [" << *it << "] " << std::endl;

    return (0);
}

[c] [b] [a]
find('A') == false
find('b') == true: [b]

unordered_multiset::get_allocator

Získá uložený objekt alokátoru.

Alloc get_allocator() const;

Poznámky

Členová funkce vrátí uložený objekt alokátoru.

Příklad

// std__unordered_set__unordered_multiset_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}

al == std::allocator() is true

unordered_multiset::hash_function

Získá uložený objekt hashovací funkce.

Hash hash_function() const;

Poznámky

Členová funkce vrátí uložený objekt funkce hash.

Příklad

// std__unordered_set__unordered_multiset_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}

hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset::hasher

Typ hashovací funkce

typedef Hash hasher;

Poznámky

Typ je synonymem pro parametr Hashšablony .

Příklad

// std__unordered_set__unordered_multiset_hasher.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}

hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset::insert

Vloží prvek nebo rozsah prvků do unordered_multiset.

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

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

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

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

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

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

Parametry

Val
Hodnota prvku, který se má vložit do unordered_multiset.

Kde
Místo zahájení vyhledání správného bodu vložení.

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

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

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

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

IList
Initializer_list, ze kterého chcete prvky zkopírovat.

Návratová hodnota

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

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

Poznámky

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

Pokud je při vložení pouze jednoho prvku vyvolána výjimka, ale nenastane v kontejneru funkce hash, stav kontejneru se nezmění. Pokud je vyvolána výjimka ve funkci hash, výsledek není definován. Pokud je při vkládání více prvků vyvolána výjimka, kontejner zůstane v neurčeném, ale platném stavu.

Value_type kontejneru je typedef, který patří do kontejneru, a pro sadu unordered_multiset<V>::value_type je typ const V.

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

Členová funkce seznamu inicializátoru (6) používá initializer_list ke kopírování prvků do unordered_multiset.

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

Příklad kódu najdete v tématu multiset::insert.

unordered_multiset::iterator

Typ, který poskytuje konstantní iterátor dopředu, který může číst prvky v unordered_multiset.

typedef implementation-defined iterator;

Příklad

Podívejte se na příklad toho, jak deklarovat a používat iterátor.

unordered_multiset::key_eq

Získá uložený objekt funkce porovnání.

Pred key_eq() const;

Poznámky

Členová funkce vrátí uložený objekt porovnávací funkce.

Příklad

// std__unordered_set__unordered_multiset_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset::key_equal

Typ funkce porovnání

typedef Pred key_equal;

Poznámky

Typ je synonymem pro parametr Predšablony .

Příklad

// std__unordered_set__unordered_multiset_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset::key_type

Typ klíče řazení

typedef Key key_type;

Poznámky

Typ je synonymem pro parametr Keyšablony .

Příklad

// std__unordered_set__unordered_multiset_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

unordered_multiset::load_factor

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

float load_factor() const;

Poznámky

Členová funkce vrátí (float)unordered_multiset::size () / (float)unordered_multiset::bucket_count(), průměrný počet prvků na kbelík.

Příklad

// std__unordered_set__unordered_multiset_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

unordered_multiset::local_iterator

Typ iterátoru kbelíku.

typedef T4 local_iterator;

Poznámky

Typ popisuje objekt, který může sloužit jako iterátor pro kontejner. Zde je popsán jako synonymum pro typ T4definovaný implementací .

Příklad

// std__unordered_set__unordered_multiset_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

unordered_multiset::max_bucket_count

Získá maximální počet kbelíků.

size_type max_bucket_count() const;

Poznámky

Členová funkce vrátí maximální povolený počet kbelíků.

Příklad

// std__unordered_set__unordered_multiset_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::max_load_factor

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

float max_load_factor() const;

void max_load_factor(float factor);

Parametry

faktor
Nový maximální zátěžový faktor.

Poznámky

První členová funkce vrátí uložený maximální zátěžový faktor. Druhá členová funkce nahradí uložený maximální zátěžový faktor faktorem.

Příklad

// std__unordered_set__unordered_multiset_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::max_size

Získá maximální velikost řízené sekvence.

size_type max_size() const;

Poznámky

Členová funkce vrátí délku nejdelší sekvence, kterou může objekt ovládat.

Příklad

// std__unordered_set__unordered_multiset_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    std::cout << "max_size() == " << c1.max_size() << std::endl;

    return (0);
}

max_size() == 4294967295

unordered_multiset::operator=

Zkopíruje tabulku hash.

unordered_multiset& operator=(const unordered_multiset& right);

unordered_multiset& operator=(unordered_multiset&& right);

Parametry

Vpravo
Zkopírovaný unordered_multiset do souboru unordered_multiset.

Poznámky

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

Příklad

// unordered_multiset_operator_as.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

int main( )
{
    using namespace std;
    unordered_multiset<int> v1, v2, v3;
    unordered_multiset<int>::iterator iter;

    v1.insert(10);

    cout << "v1 = " ;
    for (iter = v1.begin(); iter != v1.end(); iter++)
        cout << *iter << " ";
    cout << endl;

    v2 = v1;
    cout << "v2 = ";
    for (iter = v2.begin(); iter != v2.end(); iter++)
        cout << *iter << " ";
    cout << endl;

    // move v1 into v2
    v2.clear();
    v2 = move(v1);
    cout << "v2 = ";
    for (iter = v2.begin(); iter != v2.end(); iter++)
        cout << *iter << " ";
    cout << endl;
}

unordered_multiset::p ointer

Typ ukazatele na prvek

typedef Alloc::pointer pointer;

Poznámky

Typ popisuje objekt, který může sloužit jako ukazatel na prvek řízené sekvence.

Příklad

// std__unordered_set__unordered_multiset_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::key_type key = *it;
        Myset::pointer p = &key;
        std::cout << "[" << *p << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::reference

Typ odkazu na prvek

typedef Alloc::reference reference;

Poznámky

Typ popisuje objekt, který může sloužit jako odkaz na prvek řízené sekvence.

Příklad

// std__unordered_set__unordered_multiset_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::key_type key = *it;
        Myset::reference ref = key;
        std::cout << "[" << ref << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::rehash

Znovu vytvoří hashovací tabulku.

void rehash(size_type nbuckets);

Parametry

nbuckets
Požadovaný počet kbelíků.

Poznámky

Členová funkce mění počet kbelíků tak, aby byly alespoň nbuckety , a podle potřeby znovu sestaví tabulku hash.

Příklad

// std__unordered_set__unordered_multiset_rehash.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1

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

unordered_multiset::size

Spočítá počet prvků.

size_type size() const;

Poznámky

Členová funkce vrátí délku řízené sekvence.

Příklad

// std__unordered_set__unordered_multiset_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::size_type

Typ vzdálenosti bez znaménka mezi dvěma prvky

typedef T2 size_type;

Poznámky

Typ celého čísla bez znaménka popisuje objekt, který může představovat délku libovolné řízené sekvence. Zde je popsán jako synonymum pro typ T2definovaný implementací .

Příklad

// std__unordered_set__unordered_multiset_size_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;
    Myset::size_type sz = c1.size();

    std::cout << "size == " << sz << std::endl;

    return (0);
}

size == 0

unordered_multiset::swap

Zamění obsah dvou kontejnerů.

void swap(unordered_multiset& right);

Parametry

Vpravo
Kontejner, se kterým se má prohodit.

Poznámky

Členová funkce prohodí řízené sekvence mezi *this a vpravo. Pokud unordered_multiset::get_allocator() == right.get_allocator(), dojde k tomu v konstantním čase, vyvolá výjimku pouze v důsledku kopírování uloženého objektu vlastností typu Tra zneplatní žádné odkazy, ukazatele nebo iterátory, které označují prvky ve dvou kontrolovaných sekvencích. V opačném případě provede několik přiřazení prvků a konstruktor volá úměrný počtu prvků ve dvou kontrolovaných sekvencích.

Příklad

// std__unordered_set__unordered_multiset_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    Myset c2;

    c2.insert('d');
    c2.insert('e');
    c2.insert('f');

    c1.swap(c2);

    // display contents "[f] [e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    swap(c1, c2);

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[f] [e] [d]
[c] [b] [a]

unordered_multiset::unordered_multiset

Sestaví objekt kontejneru.

unordered_multiset(
    const unordered_multiset& Right);

explicit unordered_multiset(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

unordered_multiset(
    unordered_multiset&& Right);

unordered_set(
    initializer_list<Type> IList);

unordered_set(
    initializer_list<Typ> IList,
    size_type Bucket_count);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key,
    const Allocator& Al);

template <class InputIterator>
unordered_multiset(
    InputIterator First,
    InputIterator Last,
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

Parametry

InputIterator
Typ iterátoru.

Hliník
Objekt alokátoru, který se má uložit.

Comp
Objekt funkce porovnání, který se má uložit.

Hash
Objekt hashovací funkce, který se má uložit.

Bucket_count
Minimální počet kbelíků.

Right
Kontejner, který se má kopírovat.

IList
Initializer_list, ze kterého chcete kopírovat.

Poznámky

První konstruktor určuje kopii sekvence řízené vpravo. Druhý konstruktor určuje prázdnou řízenou sekvenci. Třetí konstruktor vloží sekvenci hodnot [First, Last)prvků . Čtvrtý konstruktor určuje kopii sekvence přesunutím doprava.

Všechny konstruktory také inicializují několik uložených hodnot. U konstruktoru kopírování jsou hodnoty získány zprava. Jinak:

Minimální počet kbelíků je argument Bucket_count, pokud existuje; v opačném případě se jedná o výchozí hodnotu popsanou zde jako hodnotu N0definovanou implementací .

Objekt funkce hash je argument Hash, pokud je k dispozici; jinak je Hash().

Objekt funkce porovnání je argument Comp, pokud je k dispozici; jinak je Comp().

Objekt alokátoru je argument Al, pokud je k dispozici; v opačném případě je Alloc()to .

unordered_multiset::value_type

Typ prvku

typedef Key value_type;

Poznámky

Typ popisuje prvek řízené sekvence.

Příklad

// std__unordered_set__unordered_multiset_value_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

Viz také

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

Sdílet prostřednictvím

unordered_multiset – třída

Syntaxe

Parametry

Členové

Poznámky

Požadavky

unordered_multiset::allocator_type

Poznámky

Příklad

unordered_multiset::begin

Parametry

Poznámky

Příklad

unordered_multiset::bucket

Parametry

Poznámky

Příklad

unordered_multiset::bucket_count

Poznámky

Příklad

unordered_multiset::bucket_size

Parametry

Poznámky

Příklad

unordered_multiset::cbegin

Návratová hodnota

Poznámky

unordered_multiset::cend

Návratová hodnota

Poznámky

unordered_multiset::clear

Poznámky

Příklad

unordered_multiset::const_iterator

Poznámky

Příklad

unordered_multiset::const_local_iterator

Poznámky

Příklad

unordered_multiset::const_pointer

Poznámky

Příklad

unordered_multiset::const_reference

Poznámky

Příklad

unordered_multiset::contains

Parametry

Návratová hodnota

Poznámky

Příklad

unordered_multiset::count

Parametry

Poznámky

Příklad

unordered_multiset::d ifference_type

Poznámky

Příklad

unordered_multiset::emplace

Parametry

Návratová hodnota

Poznámky

unordered_multiset::emplace_hint

Parametry

Návratová hodnota

Poznámky

unordered_multiset::empty

Poznámky

Příklad

unordered_multiset::end

Parametry

Poznámky

Příklad

unordered_multiset::equal_range

Parametry

Poznámky

Příklad

unordered_multiset::erase

Parametry

Návratová hodnota