`unordered_set` 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 každém kbelíku funkce porovnání určuje, jestli má libovolná dvojice prvků ekvivalentní ř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). Vložení prvku zneplatní žádné iterátory a odebrání elementu zneplatní pouze iterátory, které ukazují na odebraný prvek.

Syntaxe

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

Parametry

Key
Klíčový typ

Hash
Typ objektu hashovací funkce

Pred
Typ objektu funkce porovnání rovnosti

Alloc
Třída alokátoru

Členové

Typedefs

Název	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
`iterator`	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
`pointer`	Typ ukazatele na prvek
`reference`	Typ odkazu na prvek
`size_type`	Typ vzdálenosti bez znaménka mezi dvěma prvky
`value_type`	Typ prvku

Funkce

Název	Popis
`begin`	Určuje začátek řízené sekvence.
`bucket`	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.
`clear`	Odebere všechny prvky.
`contains`^C++20	Zkontrolujte, jestli existuje prvek se zadaným klíčem v objektu `unordered_set`.
`count`	Zjistí počet prvků odpovídající zadanému klíči.
`emplace`	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.
`end`	Určuje konec řízené sekvence.
`equal_range`	Najde rozsah, který odpovídá zadanému klíči.
`erase`	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.
`insert`	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.
`rehash`	Znovu vytvoří hashovací tabulku.
`size`	Spočítá počet prvků.
`swap`	Zamění obsah dvou kontejnerů.
`unordered_set`	Sestaví objekt kontejneru.

Operátory

Název	Popis
`unordered_set::operator=`	Zkopíruje tabulku hash.

Poznámky

Objekt objednává sekvenci, kterou řídí voláním dvou uložených objektů, objektu funkce porovnání typu unordered_set::key_equal a objektu hash funkce typu unordered_set::hasher. K prvnímu uloženému objektu přistupujete voláním členské funkce unordered_set::key_eq(); a k druhému uloženému objektu přistupujete voláním členské funkce unordered_set::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 třídy template unordered_multiset Třída objekt typu unordered_set zajišťuje, že key_eq()(X, Y) je vždy false pro všechny dva prvky řízené sekvence. (Klíče jsou 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í unordered_set::load_factor() překročení maximálního zátěžového faktoru, 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ů. Obecně nemůžete předpovědět pořadí prvků v řízené sekvenci. 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ěluje a uvolní úložiště pro sekvenci, která řídí prostřednictvím uloženého objektu alokátoru typu unordered_set::allocator_type. Takový objekt alokátoru musí mít stejné externí rozhraní jako objekt typu allocator. Uložený objekt alokátoru se při přiřazení objektu kontejneru nezkopíruje.

`unordered_set::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_set_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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

// unordered_set_begin.cpp
// compile using: cl.exe /EHsc /nologo /W4 /MTd
#include <unordered_set>
#include <iostream>

using namespace std;

typedef unordered_set<char> MySet;

int main()
{
    MySet c1;

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

    // display contents using range-based for
    for (auto it : c1) {
    cout << "[" << it << "] ";
    }

    cout << endl;

    // display contents using explicit for
    for (MySet::const_iterator it = c1.begin(); it != c1.end(); ++it) {
        cout << "[" << *it << "] ";
    }

    cout << std::endl;

    // display first two items
    MySet::iterator it2 = c1.begin();
    cout << "[" << *it2 << "] ";
    ++it2;
    cout << "[" << *it2 << "] ";
    cout << endl;

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

    return (0);
}

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

`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_set_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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 čísla nbucketkbelíku .

Příklad

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

typedef std::unordered_set<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

`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 odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

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

// i2 isContainer<T>::const_iterator

`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 odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje end() a cend().

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

// i2 isContainer<T>::const_iterator

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

`clear`

Odebere všechny prvky.

void clear();

Poznámky

Členské funkce volá unordered_set::erase( unordered_set::begin(), unordered_set::end()). Další informace najdete v tématech unordered_set::erase, unordered_set::begin a unordered_set::end.

Příklad

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

typedef std::unordered_set<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

`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áno jako synonymum pro typ T1definovaný implementací .

Příklad

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

typedef std::unordered_set<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]

`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áno jako synonymum pro typ T5definovaný implementací .

Příklad

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

typedef std::unordered_set<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]

`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_set_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`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_set_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`contains`

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

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_set<int> theUnorderedSet = { 1, 2 };

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theUnorderedSet.contains(2) << '\n';
    std::cout << theUnorderedSet.contains(3) << '\n';

    return 0;
}

true
false

`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é znakem unordered_set::equal_range(keyval).

Příklad

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

typedef std::unordered_set<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

`difference_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áno jako synonymum pro typ T3definovaný implementací .

Příklad

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

typedef std::unordered_set<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

`emplace`

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

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

Parametry

args
Argumenty přeposílané k vytvoření prvku, který se má vložit do objektu unordered_set , pokud již neobsahuje prvek, jehož hodnota je ekvivalentní seřazena.

Návratová hodnota

Jejíž pair bool komponenta vrátí hodnotu true, pokud byla vložena a false, pokud unordered_set již obsahoval prvek, jehož klíč měl ekvivalentní hodnotu v pořadí, a jehož iterátor komponenta vrátí adresu, kde byl vložen nový prvek nebo kde byl prvek již umístěn.

Chcete-li získat přístup ke komponentě iterátoru páru pr vrácené touto členovou funkcí, použijte pr.firsta k jeho dereferenci použijte *(pr.first). Chcete-li získat přístup ke komponentě bool páru pr vrácené touto členovou funkcí, použijte pr.second.

Poznámky

Tato funkce zneplatní žádné iterátory ani odkazy.

Pokud během vkládání dojde k výjimce, ale ve funkci hash kontejneru nedojde, 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.

`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_iteratorwhere,
Args&&... args);

Parametry

args
Argumenty předané k vytvoření prvku, který má být vložen do unordered_set , pokud unordered_set již tento prvek neobsahuje nebo obecněji, pokud již neobsahuje prvek, jehož klíč je ekvivalentně seřazen.

where
Nápověda k místu, kde můžete začít hledat správný bod vložení.

Návratová hodnota

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

Pokud vložení selhalo, protože prvek již existuje, vrátí iterátor existujícímu prvku.

Poznámky

Tato funkce zneplatní žádné iterátory ani odkazy.

Pokud během vkládání dojde k výjimce, ale ve funkci hash kontejneru nedojde, 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.

`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_set_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_end.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`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_set_equal_range.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`erase`

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

iterator erase(const_iterator Where);

iterator erase(const_iterator First, const_iterator Last);

size_type erase(const key_type& Key);

Parametry

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

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

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

Key
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 rámec všech prvků odebraných, nebo prvek, který je koncem unordered_set tohoto prvku, pokud takový prvek neexistuje.

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

Poznámky

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

`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_set::equal_range(keyval).first.

Příklad

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

typedef std::unordered_set<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]

`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_set_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`hasher`

Typ hashovací funkce

typedef Hash hasher;

Poznámky

Typ je synonymem pro parametr Hashšablony .

Příklad

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

typedef std::unordered_set<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

`insert`

Vloží prvek nebo oblast prvků do objektu unordered_set.

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

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

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

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

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

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

Parametry

Val
Hodnota prvku, který má být vložen do objektu unordered_set , pokud již neobsahuje prvek, jehož klíč je odpovídajícím způsobem seřazen.

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

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

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

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

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

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

Návratová hodnota

Členské funkce s jedním prvkem (1) a (2), vrátí pair hodnotu, jejíž bool součást je pravdivá, pokud byla vložena, a nepravda, pokud unordered_set již obsahoval prvek, jehož klíč měl ekvivalentní hodnotu v pořadí. Iterátorová komponenta dvojice návratových hodnot odkazuje na nově vložený prvek, pokud bool je truekomponenta , nebo na existující prvek, pokud je falsekomponenta bool .

Č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_set prvku nebo, pokud prvek s ekvivalentním klíčem již existuje, existující prvek.

Poznámky

Touto funkcí nejsou zneplatněny žádné iterátory, ukazatele ani odkazy.

Pokud během vkládání pouze jednoho prvku dojde k výjimce, ale ve funkci hash kontejneru nedojde, 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.

Pokud chcete získat přístup ke komponentě iterátoru pair pr vrácené členské funkce s jedním prvkem, použijte pr.first; pro dereferenci iterátoru ve vrácené dvojici použijte*pr.first, abyste poskytli prvek. Pro přístup ke komponentě bool použijte pr.second. Příklad naleznete v ukázce kódu dále v tomto článku.

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

Členová funkce oblasti (5) vloží sekvenci hodnot prvků do unordered_set prvku, který odpovídá každému prvku adresovanému iterátorem v oblasti [First, Last), a proto Last se nevloží. Členská funkce kontejneru end() se vztahuje k pozici hned za posledním prvkem v kontejneru, například příkaz s.insert(v.begin(), v.end()); se pokusí vložit všechny prvky v do s. Vkládají se pouze prvky, které v rozsahu obsahují jedinečné hodnoty. Duplicitní hodnoty jsou ignorovány. Chcete-li sledovat, které prvky jsou odmítnuty, použijte jednoprvkovou verzi funkce insert.

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

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

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

`iterator`

Typ, který poskytuje konstantní iterátor vpřed, který může číst prvky v unordered_set.

typedef implementation-defined iterator;

Příklad

Příklad toho, jak deklarovat a používat iterátor, najdete v příkladu.begin

`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_set_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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_set_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`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_set::size () / (float)unordered_set::bucket_count(), průměrný počet prvků na kbelík.

Příklad

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

typedef std::unordered_set<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

`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áno jako synonymum pro typ T4definovaný implementací .

Příklad

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

typedef std::unordered_set<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]

`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_set_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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

factor
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 znakem factor.

Příklad

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

typedef std::unordered_set<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

`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_set_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

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

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

    return (0);
}

max_size() == 4294967295

`operator=`

Zkopíruje tabulku hash.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parametry

right
Zkopírovaná unordered_set do souboru unordered_set.

Poznámky

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

Příklad

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

int main( )
{
    using namespace std;
    unordered_set<int> v1, v2, v3;
    unordered_set<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;
}

`pointer`

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_set_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`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_set_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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]

`rehash`

Znovu vytvoří hashovací tabulku.

void rehash(size_type nbuckets);

Parametry

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

Poznámky

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

Příklad

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

typedef std::unordered_set<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

`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_set_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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

`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áno jako synonymum pro typ T2definovaný implementací .

Příklad

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

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

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

    return (0);
}

size == 0

`swap`

Zamění obsah dvou kontejnerů.

void swap(unordered_set& right);

Parametry

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

Poznámky

Členová funkce prohodí řízené sekvence mezi *this a right. Pokud unordered_set::get_allocator() == right.get_allocator()to dělá v konstantním čase, vyvolá výjimku pouze v důsledku kopírování uložené vlastnosti objektu typu Tr, a zneplatňuje žádné odkazy, ukazatele nebo iterátory, které urč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_set_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<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_set`

Sestaví objekt kontejneru.

unordered_set(const unordered_set& Right);

explicit unordered_set(
    size_typebucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

unordered_set(unordered_set&& Right);

unordered_set(initializer_list<Type> IList);

unordered_set(initializer_list<Type> IList, size_typebucket_count);

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

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash,
    const Comp& Comp);

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash,
    const Comp& Comp,
    const Allocator& Al);

template <class InputIterator>
unordered_set(
    InputIteratorfirst,
    InputIteratorlast,
    size_typebucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

Parametry

InputIterator
Typ iterátoru.

Al
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
Obsahuje initializer_list prvky, které chcete zkopírovat.

Poznámky

První konstruktor určuje kopii sekvence řízené Right. Druhý konstruktor určuje prázdnou řízenou sekvenci. Třetí konstruktor určuje kopii sekvence přesunutím Right čtvrtého až osmého konstruktoru initializer_list k určení prvků, které se mají kopírovat. Devátý konstruktor vloží sekvenci hodnot[first, last) prvků.

Všechny konstruktory také inicializují několik uložených hodnot. Pro konstruktor kopírování jsou hodnoty získány z Right. 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 .

`value_type`

Typ prvku

typedef Key value_type;

Poznámky

Typ popisuje prvek řízené sekvence.

Příklad

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

typedef std::unordered_set<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]

Sdílet prostřednictvím

unordered_set Třída

Syntaxe

Parametry

Členové

Typedefs

Funkce

Operátory

Poznámky

unordered_set::allocator_type

Poznámky

Příklad

begin

Parametry

Poznámky

Příklad

bucket

Parametry

Poznámky

Příklad

bucket_count

Poznámky

Příklad

bucket_size

Parametry

Poznámky

Příklad

cbegin

Návratová hodnota

Poznámky

cend

Návratová hodnota

Poznámky

clear

Poznámky

Příklad

const_iterator

Poznámky

Příklad

const_local_iterator

Poznámky

Příklad

const_pointer

Poznámky

Příklad

const_reference

Poznámky

Příklad

contains

Parametry

Návratová hodnota

Poznámky

Příklad

count

Parametry

Poznámky

Příklad

difference_type

Poznámky

Příklad

emplace

Parametry

Návratová hodnota

Poznámky

emplace_hint

Parametry

Návratová hodnota

Poznámky

empty

Poznámky

Příklad

end

Parametry

Poznámky

Příklad

equal_range

Parametry

Poznámky

Příklad

erase

`unordered_set` Třída

`unordered_set::allocator_type`

`begin`

`bucket`

`bucket_count`

`bucket_size`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_local_iterator`

`const_pointer`

`const_reference`

`contains`

`count`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`hash_function`

`hasher`

`insert`

`iterator`

`key_eq`

`key_equal`

`key_type`

`load_factor`

`local_iterator`

`max_bucket_count`

`max_load_factor`

`max_size`

`operator=`

`pointer`

`reference`

`rehash`

`size`

`size_type`

`swap`