`unordered_map` Třída

Článek
10/12/2023

Šablona třídy popisuje objekt, který řídí různou délkovou sekvenci prvků typu std::pair<const Key, Ty>. 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 obsahuje dva objekty, klíč řazení a hodnotu. Sekvence je reprezentována způsobem, který umožňuje vyhledávání, vložení a odebrání libovolného prvku s operacemi, které mohou být nezávislé na počtu prvků v sekvenci (konstantní čas), aspoň v případě, že všechny kbelíky mají zhruba 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 navíc zneplatní žádné iterátory a odebrání prvku zneplatní pouze iterátory, které ukazují na odebraný prvek.

Syntaxe

template <class Key,
    class Ty,
    class Hash = std::hash<Key>,
    class Pred = std::equal_to<Key>,
    class Alloc = std::allocator<std::pair<const Key, Ty>>>
class unordered_map;

Parametry

Key
Klíčový typ

Ty
Mapovaný typ

Hash
Typ objektu hashovací funkce

Pred
Typ objektu funkce porovnání rovnosti

Alloc
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
`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
`mapped_type`	Typ mapované hodnoty přiřazené ke každému klíči
`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

Členská funkce	Popis
`at`	Vyhledá prvek se zadaným klíčem.
`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.
`count`	Zjistí počet prvků odpovídající zadanému klíči.
`contains`^C++20	Zkontrolujte, jestli existuje prvek se zadaným klíčem v objektu `unordered_map`.
`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_map`	Sestaví objekt kontejneru.

Operátor	Popis
`unordered_map::operator[]`	Vyhledá nebo vloží prvek se zadaným klíčem.
`unordered_map::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_map::key_equal a objektu hash funkce typu unordered_map::hasher. K prvnímu uloženému objektu přistupujete voláním členské funkce unordered_map::key_eq(); a k druhému uloženému objektu přistupujete voláním členské funkce unordered_map::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)KeyYX Na rozdíl od třídy template unordered_multimap Třída objekt typu unordered_map 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_map::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_map::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.

Požadavky

Záhlaví:<unordered_map>

Obor názvů: std

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

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

    Mymap::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_map::at`

Vyhledá prvek v unordered_map se zadanou hodnotou klíče.

Ty& at(const Key& key);
const Ty& at(const Key& key) const;

Parametry

key
Hodnota klíče, kterou chcete najít.

Vrácená hodnota

Odkaz na datovou hodnotu nalezeného prvku.

Poznámky

Pokud se hodnota klíče argumentu nenajde, funkce vyvolá objekt třídy out_of_range.

Příklad

// unordered_map_at.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // find and show elements
    std::cout << "c1.at('a') == " << c1.at('a') << std::endl;
    std::cout << "c1.at('b') == " << c1.at('b') << std::endl;
    std::cout << "c1.at('c') == " << c1.at('c') << std::endl;

    return (0);
}

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    // inspect first two items " [c 3] [b 2]"
    Mymap::iterator it2 = c1.begin();
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    ++it2;
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
}

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    // display buckets for keys
    Mymap::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, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3][b, 2][a, 1]
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_map::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_map__unordered_map_bucket_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    // display buckets for keys
    Mymap::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, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1

`unordered_map::cbegin`

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

const_iterator cbegin() const;

Vrácená 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á 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 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`unordered_map::cend`

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

const_iterator cend() const;

Vrácená 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á 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 is Container<T>::iterator
auto i2 = Container.cend();
// i2 is Container<T>::const_iterator

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

`unordered_map::clear`

Odebere všechny prvky.

void clear();

Poznámky

Členské funkce volá unordered_map::erase(unordered_map::begin(), unordered_map::end()), viz unordered_map::erase, unordered_map::begina unordered_map::end.

Příklad

// std__unordered_map__unordered_map_clear.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

    // display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

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

    return (0);
}

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

[e, 5] [d, 4]
size == 2
empty() == false

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
}

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
}

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
    {
        Mymap::const_pointer p = &*it;
        std::cout << " [" << p->first << ", " << p->second << "]";
    }
    std::cout << std::endl;

    return (0);
}

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

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

    return (0);
}

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

`unordered_map::contains`

Zkontroluje, jestli je v zadaném klíči unordered_map prvek. Představeno v jazyce C++20.

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

Parametry

K
Typ klíče.

key
Hodnota klíče prvku, který chcete vyhledat.

Vrácená 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_map>
#include <iostream>

int main()
{
    std::unordered_map<int, bool> theUnorderedMap = {{0, false}, {1,true}};

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

    return 0;
}

true
false

`unordered_map::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_map::equal_range(keyval).

Příklad

// std__unordered_map__unordered_map_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
count('A') == 0
count('b') == 1
count('C') == 0

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

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

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

    return (0);
}

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

`unordered_map::emplace`

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

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_map , pokud již neobsahuje prvek, jehož hodnota je ekvivalentní seřazena.

Vrácená hodnota

Jejíž pairbool komponenta vrátí hodnotu true, pokud byla vložena a false, pokud unordered_map 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 map::emplace.

`unordered_map::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ředané k vytvoření prvku, který má být vložen do unordered_map, pokud unordered_map již tento prvek neobsahuje, nebo obecně, pokud již neobsahuje prvek, jehož klíč je ekvivalentní seřazen.

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

Vrácená 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é 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.

Prvek value_type je dvojice, takže hodnota prvku bude seřazený pár s první komponentou, která se rovná hodnotě klíče a druhá komponenta rovna datové hodnotě prvku.

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

    // display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

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

    return (0);
}

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

[e, 5] [d, 4]
size == 2
empty() == false

`unordered_map::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.

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

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    // display results of failed search
    std::pair<Mymap::iterator, Mymap::iterator> pair1 =
        c1.equal_range('x');
    std::cout << "equal_range('x'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << " [" << pair1.first->first
        << ", " << pair1.first->second << "]";
    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->first
        << ", " << pair1.first->second << "]";
    std::cout << std::endl;

    return (0);
}

[c, 3] [b, 2] [a, 1]
equal_range('x'):
equal_range('b'): [b, 2]

`unordered_map::erase`

Odebere prvek nebo rozsah prvků v unordered_map 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

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.

Vrácená hodnota

U prvních dvou členských funkcí určuje obousměrný iterátor, který určuje první prvek, který je nad rámec všech odebraných prvků, nebo prvek, který je koncem mapy, pokud žádný takový prvek neexistuje.

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

Poznámky

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

unordered_map::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_map::equal_range(keyval).first.

Příklad

// std__unordered_map__unordered_map_find.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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
    Mymap::iterator it = c1.find('b');
    std::cout << "find('b') == "
        << std::boolalpha << (it != c1.end())
        << ": [" << it->first << ", " << it->second << "]" << std::endl;

    return (0);
}

[c, 3] [b, 2] [a, 1]
find('A') == false
find('b') == true: [b, 2]

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

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

    Mymap::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_map::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_map__unordered_map_hash_function.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    Mymap::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_map::hasher`

Typ hashovací funkce

typedef Hash hasher;

Poznámky

Typ je synonymem pro parametr Hashšablony .

Příklad

// std__unordered_map__unordered_map_hasher.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    Mymap::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_map::insert`

Vloží prvek nebo rozsah prvků do objektu unordered_map.

// (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_map, pokud již neobsahuje prvek, jehož klíč je ekvivalentně seřazen.

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

ValTy
Parametr šablony, který určuje typ argumentu, který může unordered_map použít k vytvoření elementu value_typea dokonalé předávání Val jako argumentu.

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.

Vrácená hodnota

Členské funkce s jedním prvkem (1) a (2), vrátí komponentu pairtrue, je-li bool vložena, a false pokud unordered_map 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_map 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 pairpr vrácené členské funkce s jedním prvkem, použijte pr.first; pro dereference iterátoru ve vrácené dvojici použijte *pr.first, a to tím, že vám poskytne 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 mapování map<K, V>::value_type je pair<const K, V>. Hodnota prvku je seřazená dvojice, ve které je první komponenta rovna hodnotě klíče a druhá komponenta je rovna datové hodnotě prvku.

Členová funkce oblasti (5) vloží sekvenci hodnot prvků do unordered_map, 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 m.insert(v.begin(), v.end()); se pokusí vložit všechny prvky v do m. 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.

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

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_map::emplace a unordered_map::emplace_hint.

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

`unordered_map::iterator`

Typ iterátoru řízené sekvence

typedef T0 iterator;

Poznámky

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

Příklad

// std__unordered_map__unordered_map_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::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_map::key_equal`

Typ funkce porovnání

typedef Pred key_equal;

Poznámky

Typ je synonymem pro parametr Predšablony .

Příklad

// std__unordered_map__unordered_map_key_equal.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::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_map::key_type`

Typ klíče řazení

typedef Key key_type;

Poznámky

Typ je synonymem pro parametr Keyšablony .

Příklad

// std__unordered_map__unordered_map_key_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

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

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

Příklad

// std__unordered_map__unordered_map_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
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_map::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_map__unordered_map_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

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

`unordered_map::mapped_type`

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

typedef Ty mapped_type;

Poznámky

Typ je synonymem pro parametr Tyšablony .

Příklad

// std__unordered_map__unordered_map_mapped_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
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_map::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_map__unordered_map_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
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_map::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_map__unordered_map_max_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

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

    return (0);
    }

max_size() == 536870911

`unordered_map::operator[]`

Vyhledá nebo vloží prvek se zadaným klíčem.

Ty& operator[](const Key& keyval);

Ty& operator[](Key&& keyval);

Parametry

keyval
Hodnota klíče, kterou chcete vyhledat nebo vložit.

Vrácená hodnota

Odkaz na hodnotu dat vloženého prvku.

Poznámky

Pokud se hodnota klíče argumentu nenajde, vloží se spolu s výchozí hodnotou datového typu.

operator[] lze použít k vložení prvků do mapy m , kde m[Key] = DataValue;DataValue je hodnota mapped_type prvku s hodnotou Keyklíče .

Členová funkce určuje iterátor where jako návratová unordered_map::insert(unordered_map::value_type(keyval, Ty())hodnota . Další informace najdete v tématech unordered_map::insert a unordered_map::value_type. (Vloží prvek se zadaným klíčem, pokud takový prvek neexistuje.) Pak vrátí odkaz na (*where).second.

Při použití operator[] k vložení prvků vrácený odkaz nezoznačuje, jestli vložení mění existující prvek nebo vytváří nový. Členské funkce find a insert lze je použít k určení, zda prvek se zadaným klíčem již existuje před vložením.

Příklad

// std__unordered_map__unordered_map_operator_sub.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
#include <string>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// try to find and fail
    std::cout << "c1['A'] == " << c1['A'] << std::endl;

// try to find and succeed
    std::cout << "c1['a'] == " << c1['a'] << std::endl;

// redisplay contents
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// insert by moving key
    std::unordered_map<string, int> c2;
    std::string str("abc");
    std::cout << "c2[std::move(str)] == " << c2[std::move(str)] << std::endl;
    std::cout << "c2["abc"] == " << c2["abc"] << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
c1['A'] == 0
c1['a'] == 1
[c, 3] [b, 2] [A, 0] [a, 1]
c2[move(str)] == 0
c2["abc"] == 1

`unordered_map::operator=`

Nahradí prvky tohoto unordered_map použitím prvků z jiného unordered_map.

unordered_map& operator=(const unordered_map& right);

unordered_map& operator=(unordered_map&& right);

Parametry

right
Unordered_map, ze kterého funkce operátoru přiřadí obsah.

Poznámky

První verze zkopíruje všechny prvky z right tohoto unordered_map.

Druhá verze přesune všechny prvky z right této unordered_map.

Všechny prvky, které jsou v tomto unordered_map před operator= provedením, budou zahozeny.

Příklad

// unordered_map_operator_as.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

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

   v1.insert(pair<int, int>(1, 10));

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

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

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::pointer p = &*it;
        std::cout << " [" << p->first << ", " << p->second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::reference ref = *it;
        std::cout << " [" << ref.first << ", " << ref.second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

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

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

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
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_map::size`

Spočítá počet prvků.

size_type size() const;

Poznámky

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

Příklad

// std__unordered_map__unordered_map_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

// display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

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

    return (0);
    }

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

[e, 5] [d, 4]
size == 2
empty() == false

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

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::size_type sz = c1.size();

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

    return (0);
    }

size == 0

`unordered_map::swap`

Zamění obsah dvou kontejnerů.

void swap(unordered_map& right);

Parametry

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

Poznámky

Členová funkce prohodí řízené sekvence mezi *this a right. Pokud unordered_map::get_allocator() == right.get_allocator(), viz unordered_map::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é označují prvky ve dvou kontrolovaných sekvencích. V opačném případě provádí přiřazení prvků a konstruktor volá proporcionální počet prvků ve dvou kontrolovaných sekvencích.

Příklad

// std__unordered_map__unordered_map_swap.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    Mymap c2;

    c2.insert(Mymap::value_type('d', 4));
    c2.insert(Mymap::value_type('e', 5));
    c2.insert(Mymap::value_type('f', 6));

    c1.swap(c2);

// display contents " [f 6] [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    swap(c1, c2);

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

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

`unordered_map::unordered_map`

Sestaví objekt kontejneru.

unordered_map(const unordered_map& Right);

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

unordered_map(unordered_map&& Right);
unordered_map(initializer_list<Type> IList);
unordered_map(initializer_list<Type> IList, size_type Bucket_count);

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

unordered_map(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    KeyEqual& equal);

unordered_map(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    KeyEqual& Equal
    const Allocator& Al);

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

Parametry

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.

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

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

IList
Initializer_list obsahující prvky, které se mají zkopírovat.

Poznámky

První konstruktor určuje kopii sekvence řízené right. 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 right.

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; jinak se jedná o výchozí hodnotu popsanou zde jako hodnotu N0definovanou implementací .

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

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

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

Příklad

// std__unordered_map__unordered_map_construct.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
#include <initializer_list>

using namespace std;

using Mymap = unordered_map<char, int>;

int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c2(8,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    c2.insert(Mymap::value_type('d', 4));
    c2.insert(Mymap::value_type('e', 5));
    c2.insert(Mymap::value_type('f', 6));

    // display contents " [f 6] [e 5] [d 4]"
    for (const auto& c : c2) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c3(c1.begin(),
        c1.end(),
        8,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c3) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c4(move(c3));

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c4) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
    cout << endl;

    // Construct with an initializer_list
    unordered_map<int, char> c5({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } });
    for (const auto& c : c5) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size
    unordered_map<int, char> c6({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 4);
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
    cout << endl;

    // Initializer_list plus size and hash
    unordered_map<int, char, hash<char>> c7(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size, hash, and key_equal
    unordered_map<int, char, hash<char>, equal_to<char>> c8(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>(),
        equal_to<char>()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size, hash, key_equal, and allocator
    unordered_map<int, char, hash<char>, equal_to<char>> c9(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
}

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

[5, g] [6, h] [7, i] [8, j]
[a, 1] [b, 2] [c, 3]

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

`unordered_map::value_type`

Typ prvku

typedef std::pair<const Key, Ty> value_type;

Poznámky

Typ popisuje prvek řízené sekvence.

Příklad

// std__unordered_map__unordered_map_value_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_map<char, int> Mymap;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    // add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
}

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

Viz také

<unordered_map>
Bezpečný přístup z více vláken ve standardní knihovně C++\

unordered_map Třída

Syntaxe

Parametry

Členové

Poznámky

Požadavky

unordered_map::allocator_type

Poznámky

Příklad

unordered_map::at

Parametry

Vrácená hodnota

Poznámky

Příklad

unordered_map::begin

Parametry

Poznámky

Příklad

unordered_map::bucket

Parametry

Poznámky

Příklad

unordered_map::bucket_count

Poznámky

Příklad

unordered_map::bucket_size

Parametry

Poznámky

Příklad

unordered_map::cbegin

Vrácená hodnota

Poznámky

unordered_map::cend

Vrácená hodnota

Poznámky

unordered_map::clear

Poznámky

Příklad

unordered_map::const_iterator

Poznámky

Příklad

unordered_map::const_local_iterator

Poznámky

Příklad

unordered_map::const_pointer

Poznámky

Příklad

unordered_map::const_reference

Poznámky

Příklad

unordered_map::contains

Parametry

Vrácená hodnota

Poznámky

Příklad

unordered_map::count

Parametry

Poznámky

Příklad

unordered_map::difference_type

Poznámky

Příklad

unordered_map::emplace

Parametry

Vrácená hodnota

Poznámky

unordered_map::emplace_hint

Parametry

Vrácená hodnota

Poznámky

unordered_map::empty

Poznámky

Příklad

unordered_map::end

Parametry

Poznámky

unordered_map::equal_range

Parametry

Poznámky

Příklad

`unordered_map` Třída

`unordered_map::allocator_type`

`unordered_map::at`

`unordered_map::begin`

`unordered_map::bucket`

`unordered_map::bucket_count`

`unordered_map::bucket_size`

`unordered_map::cbegin`

`unordered_map::cend`

`unordered_map::clear`

`unordered_map::const_iterator`

`unordered_map::const_local_iterator`

`unordered_map::const_pointer`

`unordered_map::const_reference`

`unordered_map::contains`

`unordered_map::count`

`unordered_map::difference_type`

`unordered_map::emplace`

`unordered_map::emplace_hint`

`unordered_map::empty`

`unordered_map::end`

`unordered_map::equal_range`

`unordered_map::erase`

`unordered_map::get_allocator`

`unordered_map::hash_function`

`unordered_map::hasher`

`unordered_map::insert`

`unordered_map::iterator`

`unordered_map::key_eq`

`unordered_map::key_equal`

`unordered_map::key_type`

`unordered_map::load_factor`

`unordered_map::local_iterator`

`unordered_map::mapped_type`

`unordered_map::max_bucket_count`

`unordered_map::max_load_factor`

`unordered_map::max_size`

`unordered_map::operator[]`

`unordered_map::operator=`

`unordered_map::pointer`

`unordered_map::reference`

`unordered_map::rehash`