`unordered_map` Klasa

Artykuł
06/16/2023

Szablon klasy opisuje obiekt, który kontroluje różną długość sekwencji elementów typu std::pair<const Key, Ty>. Sekwencja jest słabo uporządkowana według funkcji mieszania, która dzieli sekwencję na uporządkowany zestaw podsekwencji, zwanych przedziałami, segmentami lub pakietami. W każdym zasobniku funkcja porównania określa, czy dowolna para elementów ma równoważną kolejność. Każdy element przechowuje dwa obiekty, klucz sortowania i wartość. Sekwencja jest reprezentowana w sposób, który zezwala na wyszukiwanie, wstawianie i usuwanie dowolnego elementu z operacjami, które mogą być niezależne od liczby elementów w sekwencji (czas stały), co najmniej wtedy, gdy wszystkie zasobniki mają mniej więcej taką samą długość. W najgorszym przypadku, gdy wszystkie elementy znajdują się w jednym przedziale, liczba operacji jest proporcjonalna do liczby elementów w sekwencji (liniowy czas). Ponadto wstawienie elementu powoduje unieważnienie żadnych iteratorów i usunięcie elementu unieważnia tylko te iteratory wskazujące na usunięty element.

Składnia

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
Typ klucza.

Ty
Typ mapowany.

Hash
Typ obiektu funkcji mieszania.

Pred
Typ obiektu funkcji porównywania równości.

Alloc
Klasa alokatora.

Elementy członkowskie

Definicja typu	opis
`allocator_type`	Typ alokatora do zarządzania pamięcią.
`const_iterator`	Typ iteratora stałego dla kontrolowanej sekwencji.
`const_local_iterator`	Typ iteratora stałego przedziału dla kontrolowanej sekwencji.
`const_pointer`	Typ stałego wskaźnika do elementu.
`const_reference`	Typ stałego odwołania do elementu.
`difference_type`	Typ odległości ze znakiem między dwoma elementami.
`hasher`	Typ funkcji mieszania.
`iterator`	Typ iteratora dla kontrolowanej sekwencji.
`key_equal`	Typ funkcji porównywania.
`key_type`	Typ klucza sortowania.
`local_iterator`	Typ iteratora przedziału dla kontrolowanej sekwencji.
`mapped_type`	Typ mapowanej wartości skojarzonej z poszczególnymi kluczami.
`pointer`	Typ wskaźnika do elementu.
`reference`	Typ odwołania do elementu.
`size_type`	Typ odległości bez znaku między dwoma elementami.
`value_type`	Typ elementu.

Funkcja elementów członkowskich	opis
`at`	Wyszukuje element z określonym kluczem.
`begin`	Określa początek kontrolowanej sekwencji.
`bucket`	Pobiera numer przedziału dla wartości klucza.
`bucket_count`	Pobiera liczbę przedziałów.
`bucket_size`	Pobiera rozmiar przedziału.
`cbegin`	Określa początek kontrolowanej sekwencji.
`cend`	Określa koniec kontrolowanej sekwencji.
`clear`	Usuwa wszystkie elementy.
`count`	Wyszukuje liczbę elementów pasujących do określonego klucza.
`contains`^C++20	Sprawdź, czy w elemecie znajduje się element z określonym kluczem `unordered_map`.
`emplace`	Dodaje element skonstruowany na miejscu.
`emplace_hint`	Dodaje element skonstruowany na miejscu, z podpowiedzią.
`empty`	Sprawdza, czy nie ma żadnych elementów.
`end`	Określa koniec kontrolowanej sekwencji.
`equal_range`	Wyszukuje zakres, który odpowiada określonemu kluczowi.
`erase`	Usuwa elementy z określonych pozycji.
`find`	Wyszukuje element, który odpowiada określonemu kluczowi.
`get_allocator`	Pobiera przechowywany obiekt alokatora.
`hash_function`	Pobiera przechowywany obiekt funkcji mieszania.
`insert`	Dodaje elementy.
`key_eq`	Pobiera przechowywany obiekt funkcji porównywania.
`load_factor`	Oblicza średnią liczbę elementów na przedział.
`max_bucket_count`	Pobiera maksymalną liczbę przedziałów.
`max_load_factor`	Pobiera lub ustawia maksymalną liczbę elementów na przedział.
`max_size`	Pobiera maksymalny rozmiar kontrolowanej sekwencji.
`rehash`	Przebudowuje tabelę mieszania.
`size`	Liczy liczbę elementów.
`swap`	Zamienia zawartości dwóch kontenerów.
`unordered_map`	Konstruuje obiekt kontenera.

Operator	opis
`unordered_map::operator[]`	Znajduje lub wstawia element z określonym kluczem.
`unordered_map::operator=`	Kopiuje tabelę mieszania.

Uwagi

Obiekt porządkuje sekwencję, którą kontroluje, wywołując dwa przechowywane obiekty, obiekt funkcji porównania typu unordered_map::key_equal i obiekt funkcji skrótu typu unordered_map::hasher. Uzyskujesz dostęp do pierwszego przechowywanego obiektu przez wywołanie funkcji unordered_map::key_eq()składowej ; i uzyskujesz dostęp do drugiego przechowywanego obiektu przez wywołanie funkcji unordered_map::hash_function()składowej . W szczególności dla wszystkich wartości i typu wywołanie key_eq()(X, Y) zwraca wartość true tylko wtedy, gdy dwie wartości argumentów mają równoważne kolejność; wywołanie hash_function()(keyval) daje rozkład wartości typu size_t.KeyY X W przeciwieństwie do klasy szablonu unordered_multimap klasy obiekt typu unordered_map gwarantuje, że key_eq()(X, Y) zawsze jest fałsz dla dwóch elementów kontrolowanej sekwencji. (Klucze są unikatowe).

Obiekt przechowuje również współczynnik maksymalnego obciążenia, który określa maksymalną żądaną średnią liczbę elementów na przedział. Jeśli wstawianie elementu powoduje unordered_map::load_factor() przekroczenie maksymalnego współczynnika obciążenia, kontener zwiększa liczbę zasobników i ponownie kompiluje tabelę skrótów zgodnie z potrzebami.

Rzeczywista kolejność elementów w kontrolowanej sekwencji zależy od funkcji mieszania, funkcji porównywania, kolejności wstawiania, współczynnika maksymalnego obciążenia i bieżącej liczby przedziałów. Nie można ogólnie przewidzieć kolejności elementów w kontrolowanej sekwencji. Można jednak zawsze mieć pewność, że dowolny podzbiór elementów, które mają równoważną kolejność, są obok siebie w kontrolowanej sekwencji.

Obiekt przydziela i zwalnia magazyn dla sekwencji, która kontroluje za pośrednictwem przechowywanego obiektu alokatora typu unordered_map::allocator_type. Taki obiekt alokatora musi mieć ten sam interfejs zewnętrzny co obiekt typu allocator. Przechowywany obiekt alokatora nie jest kopiowany po przypisaniu obiektu kontenera.

Wymagania

Nagłówek: <unordered_map>

Przestrzeń nazw: std

`unordered_map::allocator_type`

Typ alokatora do zarządzania pamięcią.

typedef Alloc allocator_type;

Uwagi

Typ jest synonimem parametru Allocszablonu .

Przykład

// 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`

Znajduje element w unordered_map z określoną wartością klucza.

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

Parametry

key
Wartość klucza do znalezienia.

Wartość zwracana

Odwołanie do wartości danych znalezionego elementu.

Uwagi

Jeśli wartość klucza argumentu nie zostanie znaleziona, funkcja zgłasza obiekt klasy out_of_range.

Przykład

// 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`

Wyznacza początek kontrolowanej sekwencji lub zasobnika.

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

Parametry

nbucket
Numer zasobnika.

Uwagi

Pierwsze dwie funkcje składowe zwracają iterator do przodu, który wskazuje na pierwszy element sekwencji (lub tuż poza końcem pustej sekwencji). Ostatnie dwie funkcje składowe zwracają iterator do przodu, który wskazuje na pierwszy element zasobnika (lub tuż poza końcem pustego zasobnika nbucket ).

Przykład

// 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`

Pobiera numer przedziału dla wartości klucza.

size_type bucket(const Key& keyval) const;

Parametry

keyval
Wartość klucza do mapowania.

Uwagi

Funkcja składowa zwraca numer zasobnika odpowiadający obecnie wartości keyvalklucza .

Przykład

// 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`

Pobiera liczbę przedziałów.

size_type bucket_count() const;

Uwagi

Funkcja składowa zwraca bieżącą liczbę zasobników.

Przykład

// 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`

Pobiera rozmiar zasobnika

size_type bucket_size(size_type nbucket) const;

Parametry

nbucket
Numer zasobnika.

Uwagi

Funkcje składowe zwracają rozmiar numeru nbucketzasobnika .

Przykład

// 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 Zwraca iterator, który adresuje pierwszy element w zakresie.

const_iterator cbegin() const;

Wartość zwracana

const Iterator dostępu do przodu, który wskazuje na pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

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

// i2 is Container<T>::const_iterator

`unordered_map::cend`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cend() const;

Wartość zwracana

const Iterator dostępu do przodu, który wskazuje tuż poza końcem zakresu.

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje end() i cend().

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

Wartość zwracana przez cend nie powinna być wyłuszczone.

`unordered_map::clear`

Usuwa wszystkie elementy.

void clear();

Uwagi

Funkcja składowa wywołuje funkcję unordered_map::erase(unordered_map::begin(), unordered_map::end()), zobacz unordered_map::erase, unordered_map::begini unordered_map::end.

Przykład

// 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 iteratora stałego dla kontrolowanej sekwencji.

typedef T1 const_iterator;

Uwagi

Typ opisuje obiekt, który może służyć jako stały iterator do przodu dla kontrolowanej sekwencji. Jest on opisany tutaj jako synonim typu T1zdefiniowanego przez implementację .

Przykład

// 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 iteratora stałego przedziału dla kontrolowanej sekwencji.

typedef T5 const_local_iterator;

Uwagi

Typ opisuje obiekt, który może służyć jako stały iterator przesyłania dalej dla zasobnika. Jest on opisany tutaj jako synonim typu T5zdefiniowanego przez implementację .

Przykład

// 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 stałego wskaźnika do elementu.

typedef Alloc::const_pointer const_pointer;

Uwagi

Typ opisuje obiekt, który może służyć jako stały wskaźnik do elementu kontrolowanej sekwencji.

Przykład

// 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 stałego odwołania do elementu.

typedef Alloc::const_reference const_reference;

Uwagi

Typ opisuje obiekt, który może służyć jako stałe odwołanie do elementu kontrolowanej sekwencji.

Przykład

// 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`

Sprawdza, czy element znajduje się w elemecie unordered_map z określonym kluczem. Wprowadzono w języku C++20.

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

Parametry

K
Typ klucza.

key
Wartość klucza elementu do wyszukania.

Wartość zwracana

true jeśli element zostanie znaleziony w kontenerze; false inaczej.

Uwagi

contains() jest nowy w języku C++20. Aby go użyć, określ lub nowszą /std:c++20 opcję kompilatora.

template<class K> bool contains(const K& key) const Uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli key_compare jest przezroczysty.

Przykład

// 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`

Wyszukuje liczbę elementów pasujących do określonego klucza.

size_type count(const Key& keyval) const;

Parametry

keyval
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa zwraca liczbę elementów w zakresie rozdzielonym przez unordered_map::equal_range(keyval).

Przykład

// 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 odległości ze znakiem między dwoma elementami.

typedef T3 difference_type;

Uwagi

Typ liczby całkowitej ze znakiem opisuje obiekt, który może reprezentować różnicę między adresami wszystkich dwóch elementów w kontrolowanej sekwencji. Jest on opisany tutaj jako synonim typu T3zdefiniowanego przez implementację .

Przykład

// 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`

Wstawia element skonstruowany na miejscu (nie są wykonywane żadne operacje kopiowania lub przenoszenia) do unordered_map.

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

Parametry

args
Argumenty przekazywane do konstruowania elementu, który ma zostać wstawiony do unordered_map elementu , chyba że zawiera już element, którego wartość jest równoważnie uporządkowana.

Wartość zwracana

Element pair , którego bool składnik zwraca wartość true, jeśli wstawienie zostało wykonane i false, jeśli unordered_map już zawierał element, którego klucz miał równoważną wartość w kolejności, i którego składnik iteratora zwraca adres, w którym został wstawiony nowy element lub gdzie element został już zlokalizowany.

Aby uzyskać dostęp do składnika iteratora pary pr zwróconej przez tę funkcję składową, użyj polecenia i , aby go wyłuszczyć, użyj pr.firstpolecenia *(pr.first). Aby uzyskać dostęp do bool składnika pary pr zwróconej przez tę funkcję składową, użyj polecenia pr.second.

Uwagi

Ta funkcja nie unieważnia iteratorów ani odwołań.

Jeśli podczas wstawiania zgłaszany jest wyjątek, ale nie występuje w funkcji skrótu kontenera, kontener nie jest modyfikowany. Jeśli wyjątek jest zgłaszany w funkcji skrótu, wynik jest niezdefiniowany.

Aby zapoznać się z przykładem kodu, zobacz map::emplace.

`unordered_map::emplace_hint`

Wstawia element skonstruowany na miejscu (nie są wykonywane żadne operacje kopiowania lub przenoszenia) z wskazówką umieszczania.

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

Parametry

args
Argumenty przekazywane do konstruowania elementu, który ma zostać wstawiony do unordered_map, chyba że unordered_map zawiera już ten element lub, ogólnie rzecz biorąc, chyba że zawiera już element, którego klucz jest równoważnie uporządkowany.

where
Wskazówka dotycząca miejsca, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania.

Wartość zwracana

Iterator nowo wstawiony element.

Jeśli wstawianie nie powiodło się, ponieważ element już istnieje, zwraca iterator do istniejącego elementu.

Uwagi

Ta funkcja nie unieważnia odwołań.

Element value_type jest parą, dzięki czemu wartość elementu będzie uporządkowaną parą z pierwszym składnikiem równym wartości klucza i drugiemu składnikowi równemu wartości danych elementu.

Aby zapoznać się z przykładem kodu, zobacz map::emplace_hint.

`unordered_map::empty`

Sprawdza, czy nie ma żadnych elementów.

bool empty() const;

Uwagi

Funkcja składowa zwraca wartość true dla pustej kontrolowanej sekwencji.

Przykład

// 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`

Określa koniec kontrolowanej sekwencji.

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

Parametry

nbucket
Numer zasobnika.

Uwagi

Pierwsze dwie funkcje składowe zwracają iterator do przodu, który wskazuje tuż poza końcem sekwencji. Ostatnie dwie funkcje składowe zwracają iterator do przodu, który wskazuje tuż poza końcem zasobnika nbucket.

`unordered_map::equal_range`

Wyszukuje zakres, który odpowiada określonemu kluczowi.

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

Parametry

keyval
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa zwraca parę iteratorów X , tak aby [X.first, X.second) rozdzielać tylko te elementy kontrolowanej sekwencji, które mają równoważną kolejność z keyval. Jeśli takie elementy nie istnieją, obie iteratory to end().

Przykład

// 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`

Usuwa element lub zakres elementów w unordered_map z określonych pozycji lub usuwa elementy zgodne z określonym kluczem.

iterator erase(const_iterator Where);
iterator erase(const_iterator First, const_iterator Last);
size_type erase(const key_type& Key);

Parametry

Where
Położenie elementu do usunięcia.

First
Pozycja pierwszego elementu do usunięcia.

Last
Pozycja tuż poza ostatnim elementem, który ma zostać usunięty.

Key
Wartość klucza elementów do usunięcia.

Wartość zwracana

W przypadku pierwszych dwóch funkcji składowych iterator dwukierunkowy, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub elementem, który jest końcem mapy, jeśli taki element nie istnieje.

W przypadku trzeciej funkcji składowej zwraca liczbę elementów, które zostały usunięte z unordered_map.

Uwagi

Aby zapoznać się z przykładem kodu, zobacz map::erase.

unordered_map::find

Wyszukuje element, który odpowiada określonemu kluczowi.

const_iterator find(const Key& keyval) const;

Parametry

keyval
Wartość klucza do wyszukania.

Uwagi

Funkcja składowa zwraca wartość unordered_map::equal_range(keyval).first.

Przykład

// 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`

Pobiera przechowywany obiekt alokatora.

Alloc get_allocator() const;

Uwagi

Funkcja składowa zwraca przechowywany obiekt alokatora.

Przykład

// 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`

Pobiera przechowywany obiekt funkcji mieszania.

Hash hash_function() const;

Uwagi

Funkcja składowa zwraca przechowywany obiekt funkcji skrótu.

Przykład

// 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 funkcji mieszania.

typedef Hash hasher;

Uwagi

Typ jest synonimem parametru Hashszablonu .

Przykład

// 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`

Wstawia element lub zakres elementów do 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
Wartość elementu, który ma zostać wstawiony do unordered_map, chyba że zawiera już element, którego klucz jest uporządkowany równoważnie.

Where
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania.

ValTy
Parametr szablonu określający typ argumentu, którego unordered_map może użyć do skonstruowania elementu value_type, i perfect-forwards Val jako argumentu.

First
Położenie pierwszego elementu do skopiowania.

Last
Pozycja tuż poza ostatnim elementem do skopiowania.

InputIterator
Argument funkcji szablonu spełniający wymagania iteratora wejściowego wskazujący elementy typu, które mogą służyć do konstruowania value_type obiektów.

IList
Element initializer_list , z którego mają być skopiowane elementy.

Wartość zwracana

Funkcje składowe z jednym elementem, (1) i (2), zwracają pair element, którego bool składnik jest true w przypadku wstawiania, a false jeśli unordered_map już zawierał element, którego klucz miał równoważną wartość w kolejności. Składnik iteratora pary return-value wskazuje nowo wstawiony element, jeśli bool składnik to true, lub do istniejącego elementu, jeśli bool składnik ma wartość false.

Funkcje składowe single-element-with-hint( 3) i (4) zwracają iterator wskazujący położenie, w którym nowy element został wstawiony do unordered_map lub, jeśli element z równoważnym kluczem już istnieje, do istniejącego elementu.

Uwagi

Ta funkcja nie unieważnia iteratorów, wskaźników ani odwołań.

Podczas wstawiania tylko jednego elementu, jeśli zgłaszany jest wyjątek, ale nie występuje w funkcji skrótu kontenera, stan kontenera nie jest modyfikowany. Jeśli wyjątek jest zgłaszany w funkcji skrótu, wynik jest niezdefiniowany. Podczas wstawiania wielu elementów, jeśli zostanie zgłoszony wyjątek, kontener pozostanie w nieokreślonym, ale prawidłowym stanie.

Aby uzyskać dostęp do składnika pair pr iteratora zwracanego przez funkcje składowe z jednym elementem, użyj polecenia pr.first; aby wyłusić iterator w zwróconej parze, użyj polecenia *pr.first, dając element. Aby uzyskać dostęp do bool składnika, użyj polecenia pr.second. Przykładowy kod można znaleźć w dalszej części tego artykułu.

Kontener value_type to definicja typu, która należy do kontenera, a dla mapowania map<K, V>::value_type to pair<const K, V>. Wartość elementu jest uporządkowaną parą, w której pierwszy składnik jest równy wartości klucza, a drugi składnik jest równy wartości danych elementu.

Funkcja składowa zakresu (5) wstawia sekwencję wartości elementów do unordered_map, która odpowiada każdemu elementowi adresowanemu przez iterator w zakresie [First, Last); w związku z tym Last nie jest wstawiana. Funkcja end() składowa kontenera odwołuje się do pozycji tuż po ostatnim elemencie w kontenerze — na przykład instrukcja m.insert(v.begin(), v.end()); próbuje wstawić wszystkie elementy v do melementu . Wstawiane są tylko elementy, które mają unikatowe wartości w zakresie; duplikaty są ignorowane. Aby sprawdzić, które elementy są odrzucane, należy użyć wersji pojedynczego elementu programu insert.

Funkcja składowa listy inicjatora (6) używa elementu initializer_list do kopiowania elementów do unordered_map.

W przypadku wstawiania elementu skonstruowanego na miejscu — czyli nie są wykonywane żadne operacje kopiowania lub przenoszenia — zobacz unordered_map::emplace i unordered_map::emplace_hint.

Aby zapoznać się z przykładem kodu, zobacz map::insert.

`unordered_map::iterator`

Typ iteratora dla kontrolowanej sekwencji.

typedef T0 iterator;

Uwagi

Typ opisuje obiekt, który może służyć jako iterator do przodu dla kontrolowanej sekwencji. Jest on opisany tutaj jako synonim typu T0zdefiniowanego przez implementację .

Przykład

// 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`

Pobiera przechowywany obiekt funkcji porównywania.

Pred key_eq() const;

Uwagi

Funkcja składowa zwraca przechowywany obiekt funkcji porównania.

Przykład

// 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 funkcji porównywania.

typedef Pred key_equal;

Uwagi

Typ jest synonimem parametru Predszablonu .

Przykład

// 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 klucza sortowania.

typedef Key key_type;

Uwagi

Typ jest synonimem parametru Keyszablonu .

Przykład

// 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`

Oblicza średnią liczbę elementów na przedział.

float load_factor() const;

Uwagi

Funkcja składowa zwraca (float)unordered_map::size() / (float)unordered_map::bucket_count()wartość , średnią liczbę elementów na zasobnik, zobacz unordered_map::size i unordered_map::bucket_count.

Przykład

// 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 iteratora zasobnika.

typedef T4 local_iterator;

Uwagi

Typ opisuje obiekt, który może służyć jako iterator do przodu dla zasobnika. Jest on opisany tutaj jako synonim typu T4zdefiniowanego przez implementację .

Przykład

// 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 mapowanej wartości skojarzonej z poszczególnymi kluczami.

typedef Ty mapped_type;

Uwagi

Typ jest synonimem parametru Tyszablonu .

Przykład

// 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`

Pobiera maksymalną liczbę przedziałów.

size_type max_bucket_count() const;

Uwagi

Funkcja składowa zwraca maksymalną dozwoloną liczbę zasobników.

Przykład

// 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`

Pobiera lub ustawia maksymalną liczbę elementów na przedział.

float max_load_factor() const;

void max_load_factor(float factor);

Parametry

factor
Nowy maksymalny współczynnik obciążenia.

Uwagi

Pierwsza funkcja składowa zwraca przechowywany maksymalny współczynnik obciążenia. Druga funkcja składowa zastępuje przechowywany maksymalny współczynnik obciążenia parametrem factor.

Przykład

// 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`

Pobiera maksymalny rozmiar kontrolowanej sekwencji.

size_type max_size() const;

Uwagi

Funkcja składowa zwraca długość najdłuższej sekwencji, którą obiekt może kontrolować.

Przykład

// 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[]`

Znajduje lub wstawia element z określonym kluczem.

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

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

Parametry

keyval
Wartość klucza, która ma być znaleziona lub wstawiona.

Wartość zwracana

Odwołanie do wartości danych wstawionego elementu.

Uwagi

Jeśli wartość klucza argumentu nie zostanie znaleziona, zostanie wstawiona wraz z wartością domyślną typu danych.

operator[] może służyć do wstawiania elementów do mapy m przy użyciu m[Key] = DataValue; metody where DataValue jest wartością mapped_type elementu z wartością Keyklucza .

Funkcja składowa określa iterator where jako wartość zwracaną elementu unordered_map::insert(unordered_map::value_type(keyval, Ty()). Aby uzyskać więcej informacji, zobacz tematy unordered_map::insert oraz unordered_map::value_type. (Wstawia element z określonym kluczem, jeśli taki element nie istnieje). Następnie zwraca odwołanie do (*where).second.

W przypadku użycia operator[] funkcji wstawiania elementów zwrócone odwołanie nie wskazuje, czy wstawienie zmienia wstępnie istniejący element, czy tworzy nowy. Funkcje find składowe i insert mogą służyć do określenia, czy element z określonym kluczem jest już obecny przed wstawieniem.

Przykład

// 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=`

Zastępuje elementy tego unordered_map przy użyciu elementów z innego unordered_map.

unordered_map& operator=(const unordered_map& right);

unordered_map& operator=(unordered_map&& right);

Parametry

right
Unordered_map, z którego funkcja operatora przypisuje zawartość.

Uwagi

Pierwsza wersja kopiuje wszystkie elementy z right tego unordered_map.

Druga wersja przenosi wszystkie elementy z right tego unordered_map.

Wszystkie elementy, które znajdują się w tym unordered_map przed operator= wykonaniem, zostaną odrzucone.

Przykład

// 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 wskaźnika do elementu.

typedef Alloc::pointer pointer;

Uwagi

Typ opisuje obiekt, który może służyć jako wskaźnik do elementu kontrolowanej sekwencji.

Przykład

// 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 odwołania do elementu.

typedef Alloc::reference reference;

Uwagi

Typ opisuje obiekt, który może służyć jako odwołanie do elementu kontrolowanej sekwencji.

Przykład

// 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`

Przebudowuje tabelę mieszania.

void rehash(size_type nbuckets);

Parametry

nbuckets
Żądana liczba zasobników.

Uwagi

Funkcja składowa zmienia liczbę zasobników na co najmniej i nbuckets ponownie kompiluje tabelę skrótów zgodnie z potrzebami.

Przykład

// 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`

Liczy liczbę elementów.

size_type size() const;

Uwagi

Funkcja składowa zwraca długość kontrolowanej sekwencji.

Przykład

// 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 odległości bez znaku między dwoma elementami.

typedef T2 size_type;

Uwagi

Typ liczby całkowitej bez znaku opisuje obiekt, który może reprezentować długość dowolnej kontrolowanej sekwencji. Jest on opisany tutaj jako synonim typu T2zdefiniowanego przez implementację .

Przykład

// 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`

Zamienia zawartości dwóch kontenerów.

void swap(unordered_map& right);

Parametry

right
Kontener do zamiany.

Uwagi

Funkcja składowa zamienia kontrolowane sekwencje między *this i right. Jeśli unordered_map::get_allocator() == right.get_allocator(), zobacz unordered_map::get_allocator, robi to w stałym czasie, zgłasza wyjątek tylko w wyniku skopiowania przechowywanego obiektu cech typu Tri unieważnia brak odwołań, wskaźników lub iteratorów, które wyznaczają elementy w dwóch kontrolowanych sekwencjach. W przeciwnym razie wykonuje przypisania elementów i konstruktor wywołuje proporcjonalnie do liczby elementów w dwóch kontrolowanych sekwencjach.

Przykład

// 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`

Konstruuje obiekt kontenera.

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
Obiekt alokatora, który ma być przechowywany.

Comp
Obiekt funkcji porównywania, który ma być przechowywany.

Hash
Obiekt funkcji mieszania, który ma być przechowywany.

Bucket_count
Minimalna liczba przedziałów.

Right
Kontener, który ma być skopiowany.

First
Położenie pierwszego elementu do skopiowania.

Last
Pozycja tuż poza ostatnim elementem do skopiowania.

IList
Initializer_list, który zawiera elementy do skopiowania.

Uwagi

Pierwszy konstruktor określa kopię sekwencji kontrolowanej przez rightelement . Drugi konstruktor określa pustą kontrolowaną sekwencję. Trzeci konstruktor wstawia sekwencję wartości [first, last)elementów . Czwarty konstruktor określa kopię sekwencji, przenosząc rightelement .

Wszystkie konstruktory również inicjują kilka przechowywanych wartości. W przypadku konstruktora kopiowania wartości są uzyskiwane z Rightklasy . W przeciwnym razie:

minimalna liczba zasobników jest argumentem Bucket_count, jeśli istnieje; w przeciwnym razie jest to wartość domyślna opisana tutaj jako wartość N0zdefiniowana przez implementację .

obiekt funkcji skrótu jest argumentem Hash, jeśli istnieje; w przeciwnym razie jest to Hash().

Obiekt funkcji porównania jest argumentem Comp, jeśli istnieje; w przeciwnym razie jest to Pred().

Obiekt alokatora jest argumentem Al, jeśli istnieje; w przeciwnym razie jest to Alloc().

Przykład

// 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 elementu.

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

Uwagi

Typ opisuje element kontrolowanej sekwencji.

Przykład

// 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]

Zobacz też

<unordered_map>
Bezpieczeństwo wątku w standardowej bibliotece C++\

Udostępnij za pośrednictwem

unordered_map Klasa

Składnia

Parametry

Elementy członkowskie

Uwagi

Wymagania

unordered_map::allocator_type

Uwagi

Przykład

unordered_map::at

Parametry

Wartość zwracana

Uwagi

Przykład

unordered_map::begin

Parametry

Uwagi

Przykład

unordered_map::bucket

Parametry

Uwagi

Przykład

unordered_map::bucket_count

Uwagi

Przykład

unordered_map::bucket_size

Parametry

Uwagi

Przykład

unordered_map::cbegin

Wartość zwracana

Uwagi

unordered_map::cend

Wartość zwracana

Uwagi

unordered_map::clear

Uwagi

Przykład

unordered_map::const_iterator

Uwagi

Przykład

unordered_map::const_local_iterator

Uwagi

Przykład

unordered_map::const_pointer

Uwagi

Przykład

unordered_map::const_reference

Uwagi

Przykład

unordered_map::contains

Parametry

Wartość zwracana

Uwagi

Przykład

unordered_map::count

Parametry

Uwagi

Przykład

unordered_map::difference_type

Uwagi

Przykład

unordered_map::emplace

Parametry

Wartość zwracana

Uwagi

unordered_map::emplace_hint

Parametry

Wartość zwracana

Uwagi

unordered_map::empty

Uwagi

Przykład

unordered_map::end

Parametry

Uwagi

unordered_map::equal_range

Parametry

Uwagi

`unordered_map` Klasa

`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`