`unordered_set` Klasa

Artykuł
10/12/2023

Szablon klasy opisuje obiekt, który kontroluje różną długość sekwencji elementów typu const Key. 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 służy jako zarówno klucz sortowania, jak i wartość. Sekwencja jest reprezentowana w sposób, który pozwala na wyszukiwanie, wstawianie i usuwanie dowolnego elementu z wielu operacji, które mogą być niezależne od liczby elementów w sekwencji (stały czas), co najmniej kiedy wszystkie przedziały są w przybliżeniu jednakowej długości. W najgorszym przypadku, gdy wszystkie elementy znajdują się w jednym przedziale, liczba operacji jest proporcjonalna do liczby elementów w sekwencji (liniowy czas). Wstawianie elementu powoduje unieważnienie żadnych iteratorów i usunięcie elementu unieważnia tylko te iteratory, które wskazują na usunięty element.

Składnia

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

Parametry

Key
Typ klucza.

Hash
Typ obiektu funkcji mieszania.

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

Alloc
Klasa alokatora.

Członkowie

Typedefs

Nazwa/nazwisko	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.
`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.

Funkcje

Nazwa/nazwisko	opis
`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.
`contains`^C++20	Sprawdź, czy w elemecie znajduje się element z określonym kluczem `unordered_set`.
`count`	Wyszukuje liczbę elementów pasujących do określonego klucza.
`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_set`	Konstruuje obiekt kontenera.

Operatory

Nazwa/nazwisko	opis
`unordered_set::operator=`	Kopiuje tabelę mieszania.

Uwagi

Obiekt porządkuje sekwencję, którą kontroluje, wywołując dwa przechowywane obiekty, obiekt funkcji porównania typu unordered_set::key_equal i obiekt funkcji skrótu typu unordered_set::hasher. Uzyskujesz dostęp do pierwszego przechowywanego obiektu przez wywołanie funkcji unordered_set::key_eq()składowej ; i uzyskujesz dostęp do drugiego przechowywanego obiektu przez wywołanie funkcji unordered_set::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.KeyYX W przeciwieństwie do klasy szablonu unordered_multiset klasy obiekt typu unordered_set 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_set::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_set::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.

`unordered_set::allocator_type`

Typ alokatora do zarządzania pamięcią.

typedef Alloc allocator_type;

Uwagi

Typ jest synonimem parametru Allocszablonu .

Przykład

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

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

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

    return (0);
}

al == std::allocator() is true

`begin`

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

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

using namespace std;

typedef unordered_set<char> MySet;

int main()
{
    MySet c1;

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

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

    cout << endl;

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

    cout << std::endl;

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

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

    return (0);
}

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

`bucket`

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

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

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

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

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

    return (0);
}

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

`bucket_count`

Pobiera liczbę przedziałów.

size_type bucket_count() const;

Uwagi

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

Przykład

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

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

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

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

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

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

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

    return (0);
}

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

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

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

`bucket_size`

Pobiera rozmiar zasobnika

size_type bucket_size(size_type nbucket) const;

Parametry

nbucket
Numer zasobnika.

Uwagi

Funkcje składowe zwracają rozmiar liczby nbucketzasobnika .

Przykład

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

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

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

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

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

    return (0);
}

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

`cbegin`

const 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 w połączeniu 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 isContainer<T>::iterator
auto i2 = Container.cbegin();

// i2 isContainer<T>::const_iterator

`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 w połączeniu 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 isContainer<T>::iterator
auto i2 = Container.cend();

// i2 isContainer<T>::const_iterator

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

`clear`

Usuwa wszystkie elementy.

void clear();

Uwagi

Funkcja składowa wywołuje funkcję unordered_set::erase( unordered_set::begin(), unordered_set::end()). Aby uzyskać więcej informacji, zobacz tematy unordered_set::erase, unordered_set::begin oraz unordered_set::end.

Przykład

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

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

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

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

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

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

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

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

    return (0);
}

[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false

`const_iterator`

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

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

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

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

    return (0);
}

[c] [b] [a]

`const_local_iterator`

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

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

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

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

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

    return (0);
}

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

`const_pointer`

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

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

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

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

    return (0);
}

[c] [b] [a]

`const_reference`

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

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

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

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

    return (0);
}

[c] [b] [a]

`contains`

Sprawdza, czy w elemecie znajduje się element z określonym kluczem unordered_set.

bool contains(const Key& key) const;
template<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 /std:c++20 lub nowszą 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_set>
#include <iostream>

int main()
{
    std::unordered_set<int> theUnorderedSet = { 1, 2 };

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

    return 0;
}

true
false

`count`

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

Przykład

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

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

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

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

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

    return (0);
}

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

`difference_type`

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

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

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

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

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

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

    return (0);
}

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

`emplace`

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

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

Parametry

args
Argumenty przekazywane do konstruowania elementu, który ma zostać wstawiony do unordered_set 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_set 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 set::emplace.

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

Parametry

args
Argumenty przekazywane do konstruowania elementu, który ma zostać wstawiony do unordered_set elementu , chyba unordered_set że już zawiera 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 iteratorów ani odwołań.

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

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

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

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

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

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

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

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

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

    return (0);
}

[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false

`end`

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.

Przykład

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

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

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

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

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

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

    return (0);
}

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

`equal_range`

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

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

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

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

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

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

    return (0);
}

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

`erase`

Usuwa element lub zakres elementów z unordered_set 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 dwóch pierwszych funkcji składowych iterator dwukierunkowy, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub element, który jest końcem unordered_set elementu , jeśli taki element nie istnieje.

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

Uwagi

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

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

Przykład

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

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

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

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

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

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

    return (0);
}

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

`get_allocator`

Pobiera przechowywany obiekt alokatora.

Alloc get_allocator() const;

Uwagi

Funkcja składowa zwraca przechowywany obiekt alokatora.

Przykład

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

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

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

    return (0);
}

al == std::allocator() is true

`hash_function`

Pobiera przechowywany obiekt funkcji mieszania.

Hash hash_function() const;

Uwagi

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

Przykład

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

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

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

    return (0);
}

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

`hasher`

Typ funkcji mieszania.

typedef Hash hasher;

Uwagi

Typ jest synonimem parametru Hashszablonu .

Przykład

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

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

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

    return (0);
}

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

`insert`

Wstawia element lub zakres elementów do elementu unordered_set.

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

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

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

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

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

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

Parametry

Val
Wartość elementu, który ma zostać wstawiony do unordered_set obiektu , 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óry unordered_set może służyć do konstruowania 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 wartość, której bool składnik ma wartość true, jeśli wstawienie zostało wykonane, i false, jeśli unordered_set 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_set elementu 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 iteratora elementu zwróconego pairpr 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 jest typedef, który należy do kontenera, a dla zestawu unordered_set<V>::value_type jest typem const V.

Funkcja składowa zakresu (5) wstawia sekwencję wartości elementów do unordered_set elementu odpowiadającego każdemu elementowi adresowanemu przez iterator w zakresie [First, Last); w związku z tym Last nie zostanie wstawiona. Funkcja end() składowa kontenera odwołuje się do pozycji tuż po ostatnim elemencie w kontenerze — na przykład instrukcja s.insert(v.begin(), v.end()); próbuje wstawić wszystkie elementy v do selementu . 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 elementu unordered_set.

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

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

`iterator`

Typ, który udostępnia iterator ciągłego przekazywania dalej, który może odczytywać elementy w unordered_set.

typedef implementation-defined iterator;

Przykład

Zapoznaj się z przykładem begin sposobu deklarowania i używania iteratora.

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

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

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

    return (0);
}

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

`key_equal`

Typ funkcji porównywania.

typedef Pred key_equal;

Uwagi

Typ jest synonimem parametru Predszablonu .

Przykład

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

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

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

    return (0);
}

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

`key_type`

Typ klucza sortowania.

typedef Key key_type;

Uwagi

Typ jest synonimem parametru Keyszablonu .

Przykład

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

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

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

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

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

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

    return (0);
}

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

`load_factor`

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

float load_factor() const;

Uwagi

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

Przykład

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

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

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

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

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

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

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

    return (0);
}

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

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

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

`local_iterator`

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

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

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

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

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

    return (0);
}

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

`max_bucket_count`

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

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

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

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

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

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

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

    return (0);
}

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

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

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

`max_load_factor`

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

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

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

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

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

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

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

    return (0);
}

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

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

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

`max_size`

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

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

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

    return (0);
}

max_size() == 4294967295

`operator=`

Kopiuje tabelę mieszania.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parametry

right
Element unordered_set kopiowany do pliku unordered_set.

Uwagi

Po wymazaniu wszystkich istniejących elementów w obiekcie unordered_setoperator= element kopiuje lub przenosi zawartość right do elementu unordered_set.

Przykład

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

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

    v1.insert(10);

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

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

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

`pointer`

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

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

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

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

    return (0);
}

[c] [b] [a]

`reference`

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

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

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

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

    return (0);
}

[c] [b] [a]

`rehash`

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

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

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

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

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

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

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

    return (0);
}

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

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

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

`size`

Liczy liczbę elementów.

size_type size() const;

Uwagi

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

Przykład

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

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

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

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

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

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

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

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

    return (0);
}

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

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

`size_type`

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

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

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

    return (0);
}

size == 0

`swap`

Zamienia zawartości dwóch kontenerów.

void swap(unordered_set& right);

Parametry

right
Kontener do zamiany.

Uwagi

Funkcja składowa zamienia kontrolowane sekwencje między *this i right. Jeśli unordered_set::get_allocator() == right.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 wiele przypisań elementów i wywołań konstruktora proporcjonalnie do liczby elementów w dwóch kontrolowanych sekwencjach.

Przykład

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

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

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

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

    Myset c2;

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

    c1.swap(c2);

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

    swap(c1, c2);

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

    return (0);
}

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

`unordered_set`

Konstruuje obiekt kontenera.

unordered_set(const unordered_set& Right);

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

unordered_set(unordered_set&& Right);

unordered_set(initializer_list<Type> IList);

unordered_set(initializer_list<Type> IList, size_typebucket_count);

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

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

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

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

Parametry

InputIterator
Typ iteratora.

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.

IList
Element initializer_list zawierający elementy do skopiowania.

Uwagi

Pierwszy konstruktor określa kopię sekwencji kontrolowanej przez Rightelement . Drugi konstruktor określa pustą kontrolowaną sekwencję. Trzeci konstruktor określa kopię sekwencji, przenosząc Right czwarty do ósmych konstruktorów, użyj elementu , initializer_list aby określić elementy do skopiowania. Dziewiąty konstruktor wstawia sekwencję wartości[first, last) elementów.

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 to argument 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 Comp().

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

`value_type`

Typ elementu.

typedef Key value_type;

Uwagi

Typ opisuje element kontrolowanej sekwencji.

Przykład

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

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

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

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

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

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

    return (0);
}

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

Udostępnij za pośrednictwem

unordered_set Klasa

Składnia

Parametry

Członkowie

Typedefs

Funkcje

Operatory

Uwagi

unordered_set::allocator_type

Uwagi

Przykład

begin

Parametry

Uwagi

Przykład

bucket

Parametry

Uwagi

Przykład

bucket_count

Uwagi

Przykład

bucket_size

Parametry

Uwagi

Przykład

cbegin

Wartość zwracana

Uwagi

cend

Wartość zwracana

Uwagi

clear

Uwagi

Przykład

const_iterator

Uwagi

Przykład

const_local_iterator

Uwagi

Przykład

const_pointer

Uwagi

Przykład

const_reference

Uwagi

Przykład

contains

Parametry

Wartość zwracana

Uwagi

Przykład

count

Parametry

Uwagi

Przykład

difference_type

Uwagi

Przykład

emplace

Parametry

Wartość zwracana

Uwagi

emplace_hint

Parametry

Wartość zwracana

Uwagi

empty

Uwagi

Przykład

end

Parametry

Uwagi

Przykład

equal_range

Parametry

Uwagi

Przykład

erase

`unordered_set` Klasa

`unordered_set::allocator_type`

`begin`

`bucket`

`bucket_count`

`bucket_size`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_local_iterator`

`const_pointer`

`const_reference`

`contains`

`count`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`hash_function`

`hasher`

`insert`

`iterator`

`key_eq`

`key_equal`

`key_type`

`load_factor`

`local_iterator`

`max_bucket_count`

`max_load_factor`

`max_size`

`operator=`

`pointer`

`reference`

`rehash`

`size`

`size_type`

`swap`