Класс `unordered_set`

Статья
10/12/2023

Шаблон класса описывает объект, который управляет последовательностью элементов типа const Keyс переменной длиной. Последовательность слабо упорядочена хэш-функцией, которая разделяет последовательность в упорядоченный набор подпоследовательностей, называемых блоками. В каждом контейнере функция сравнения определяет, имеет ли любая пара элементов эквивалентное упорядочение. Каждый элемент используется в качестве ключа сортировки и в качестве значения. Последовательность представляется в виде, позволяющем выполнять поиск, вставку и удаление произвольного элемента несколькими операциями, которые могут не зависеть от числа элементов в последовательности (постоянное время), по крайней мере, когда все блоки имеют примерно одинаковую длину. В худшем случае, когда все элементы находятся в одном блоке, количество операций пропорционально количеству элементов в последовательности (линейное время). При вставке элемента не выполняется итератор, а удаление элемента делает недействительными только те итераторы, которые указывают на удаленный элемент.

Синтаксис

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

Параметры

Key
Тип ключа.

Hash
Тип объекта хэш-функции.

Pred
Тип объекта функции сравнения на предмет равенства.

Alloc
Класс распределителя.

Участники

Определения типов

Имя	Описание
`allocator_type`	Тип распределителя для управления хранилищем.
`const_iterator`	Тип постоянного итератора для управляемой последовательности.
`const_local_iterator`	Тип постоянного итератора блока для управляемой последовательности.
`const_pointer`	Тип постоянного указателя на элемент.
`const_reference`	Тип постоянной ссылки на элемент.
`difference_type`	Тип расстояния со знаком между двумя элементами.
`hasher`	Тип хэш-функции.
`iterator`	Тип итератора для управляемой последовательности.
`key_equal`	Тип функции сравнения.
`key_type`	Тип ключа упорядочения.
`local_iterator`	Тип итератора блока для управляемой последовательности.
`pointer`	Тип указателя на элемент.
`reference`	Тип ссылки на элемент.
`size_type`	Тип беззнакового расстояния между двумя элементами.
`value_type`	Тип элемента.

Функции

Имя	Описание
`begin`	Задает начало управляемой последовательности.
`bucket`	Получает номер блока для значения ключа.
`bucket_count`	Получает количество блоков.
`bucket_size`	Получает размер блока.
`cbegin`	Задает начало управляемой последовательности.
`cend`	Задает конец управляемой последовательности.
`clear`	Удаляет все элементы.
`contains`^C++20	Проверьте, есть ли элемент с указанным ключом в элементе `unordered_set`.
`count`	Определяет количество элементов, соответствующих заданному ключу.
`emplace`	Добавляет элемент, созданный на месте.
`emplace_hint`	Добавляет элемент, созданный на месте, с подсказкой.
`empty`	Проверяет отсутствие элементов.
`end`	Задает конец управляемой последовательности.
`equal_range`	Находит диапазон, соответствующий указанному ключу.
`erase`	Удаляет элементы в указанных позициях.
`find`	Определяет элемент, соответствующий указанному ключу.
`get_allocator`	Возвращает сохраненный объект распределителя.
`hash_function`	Получает сохраненный объект хэш-функции.
`insert`	Добавляет элементы.
`key_eq`	Получает сохраненный объект функции сравнения.
`load_factor`	Подсчитывает среднее число элементов в блоке.
`max_bucket_count`	Получает максимальное количество блоков.
`max_load_factor`	Возвращает или задает максимальное количество элементов в блоке.
`max_size`	Возвращает максимальный размер управляемой последовательности.
`rehash`	Повторно создает хэш-таблицу.
`size`	Подсчитывает количество элементов.
`swap`	Меняет местами содержимое двух контейнеров.
`unordered_set`	Создает объект контейнера.

Операторы

Имя	Описание
`unordered_set::operator=`	Копирует хэш-таблицу.

Замечания

Объект упорядочивает последовательность, которая управляется путем вызова двух хранимых объектов, объекта функции сравнения типа unordered_set::key_equal и объекта хэш-функции типа unordered_set::hasher. Вы обращаетесь к первому сохраненного объекта, вызывая функцию-член unordered_set::key_eq(); и обращаетесь ко второму хранящейся объекту, вызывая функцию-член unordered_set::hash_function(). В частности, для всех значений X и Y типа Key вызов key_eq()(X, Y) возвращает значение true, только если два значения аргументов имеют соответствующий порядок; вызов hash_function()(keyval) создает распределение значений типа size_t. В отличие от класса шаблона unordered_multiset класса, объект типа unordered_set гарантирует, что key_eq()(X, Y) всегда имеет значение false для всех двух элементов управляемой последовательности. (Ключи уникальны).

Объект также хранит максимальный коэффициент нагрузки, который определяет максимальное желаемое среднее количество элементов в блоке. Если вставка элемента приводит unordered_set::load_factor() к превышению максимального коэффициента нагрузки, контейнер увеличивает количество контейнеров и перестраивает хэш-таблицу по мере необходимости.

Фактический порядок элементов в управляемой последовательности зависит от хэш-функции, функции сравнения, порядка вставки, максимального коэффициента нагрузки и текущего числа блоков. Вы не можете в целом предсказать порядок элементов в управляемой последовательности. Однако всегда можно сохранять уверенность, что любое подмножество элементов, имеющих соответствующий порядок, будет расположено по соседству в управляемой последовательности.

Объект выделяет и освобождает хранилище для последовательности, который он управляет с помощью сохраненного объекта распределителя типа unordered_set::allocator_type. Такой объект распределителя должен иметь тот же внешний интерфейс, что и объект типа allocator. Сохраненный объект распределителя не копируется при назначении объекта контейнера.

`unordered_set::allocator_type`

Тип распределителя для управления хранилищем.

typedef Alloc allocator_type;

Замечания

Этот тип является синонимом для параметра шаблона Alloc.

Пример

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

Задает начало управляемой последовательности или сегмента.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Параметры

nbucket
Номер сегмента.

Замечания

Первые две функции-члены возвращают прямой итератор, указывающий на первый элемент последовательности (или на место сразу за концом пустой последовательности). Последние две функции-члены возвращают прямой итератор, указывающий на первый элемент сегмента nbucket (или на место сразу за концом пустого сегмента).

Пример

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

Получает номер блока для значения ключа.

size_type bucket(const Key& keyval) const;

Параметры

keyval
Значение ключа для сопоставления.

Замечания

Функция-член возвращает номер контейнера, который в настоящий момент соответствует значению ключа keyval.

Пример

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

Получает количество блоков.

size_type bucket_count() const;

Замечания

Функция-член возвращает текущее число блоков.

Пример

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

Получает размер сегмента.

size_type bucket_size(size_type nbucket) const;

Параметры

nbucket
Номер сегмента.

Замечания

Функции-члены возвращают размер номера сегмента nbucket.

Пример

// 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, направленный на первый элемент в диапазоне.

const_iterator cbegin() const;

Возвращаемое значение

Итератор прямого доступа const, который указывает на первый элемент диапазона или расположение прямо за концом пустого диапазона (cbegin() == cend() для пустого диапазона).

Замечания

При возвращаемом значении cbeginэлементы в диапазоне не могут быть изменены.

Эту функцию-член можно использовать вместо функции-члена begin(), чтобы гарантировать, что возвращаемое значение будет const_iterator. Как правило, он используется в сочетании с ключевое слово вычета auto типов, как показано в следующем примере. В примере Container следует рассматривать как изменяемый (не-const) контейнер любого вида, который поддерживает begin() и cbegin().

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

// i2 isContainer<T>::const_iterator

`cend`

Возвращает итератор const, который обращается к месту, следующему сразу за последним элементом в диапазоне.

const_iterator cend() const;

Возвращаемое значение

Итератор const прямого доступа, который указывает на позицию сразу за концом диапазона.

Замечания

cend используется для проверки того, прошел ли итератор конец диапазона.

Эту функцию-член можно использовать вместо функции-члена end(), чтобы гарантировать, что возвращаемое значение будет const_iterator. Как правило, он используется в сочетании с ключевое слово вычета auto типов, как показано в следующем примере. В примере Container следует рассматривать как изменяемый (не-const) контейнер любого вида, который поддерживает end() и cend().

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

// i2 isContainer<T>::const_iterator

Возвращаемое cend значение не должно быть разоменовывано.

`clear`

Удаляет все элементы.

void clear();

Замечания

Вызовы unordered_set::erase( unordered_set::begin()функции-члены , unordered_set::end()). Дополнительные сведения см. в статьях unordered_set::erase, unordered_set::begin и unordered_set::end.

Пример

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

Тип постоянного итератора для управляемой последовательности.

typedef T1 const_iterator;

Замечания

Тип описывает объект, который можно использовать в качестве постоянного прямого итератора для управляемой последовательности. Здесь описано как синоним определенного реализацией типа T1.

Пример

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

Тип постоянного итератора блока для управляемой последовательности.

typedef T5 const_local_iterator;

Замечания

Этот тип описывает объект, который можно использовать в качестве постоянного прямого итератора для блока. Здесь описано как синоним определенного реализацией типа T5.

Пример

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

Тип постоянного указателя на элемент.

typedef Alloc::const_pointer const_pointer;

Замечания

Этот тип описывает объект, который можно использовать в качестве постоянного указателя на элемент управляемой последовательности.

Пример

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

Тип постоянной ссылки на элемент.

typedef Alloc::const_reference const_reference;

Замечания

Тип описывает объект, который можно использовать в качестве постоянной ссылки на элемент управляемой последовательности.

Пример

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

Проверяет, есть ли элемент с указанным ключом в элементе unordered_set.

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

Параметры

K
Тип ключа.

Key
Значение ключа элемента для поиска.

Возвращаемое значение

true Значение , если элемент найден в контейнере; false Иначе.

Замечания

contains() новый в C++20. Чтобы использовать его, укажите параметр компилятора /std:c++20 или более поздней версии.

template<class K> bool contains(const K& key) const только принимает участие в разрешении перегрузки, если key_compare это прозрачно.

Пример

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

Определяет количество элементов, соответствующих заданному ключу.

size_type count(const Key& keyval) const;

Параметры

keyval
Искомое значение ключа.

Замечания

Функция-член возвращает количество элементов в диапазоне с разделителями unordered_set::equal_range(keyval).

Пример

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

Тип расстояния со знаком между двумя элементами.

typedef T3 difference_type;

Замечания

Тип целого числа со знаком описывает объект, который может представлять разницу между адресами любых двух элементов в управляемой последовательности. Здесь описано как синоним определенного реализацией типа T3.

Пример

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

Вставляет элемент, созданный на месте (операции копирования или перемещения не выполняются).

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

Параметры

args
Аргументы, пересылаемые для создания элемента, вставляемого в unordered_set элемент, если он еще не содержит элемент, значение которого эквивалентно упорядочено.

Возвращаемое значение

Объект pair, компонент bool которого возвращает значение true, если была осуществлена вставка, и false, если unordered_set уже содержал элемент, ключ которого имел эквивалентное значение порядка, и компонент итератора которого возвращает адрес нового вставленного элемента или адрес местонахождения элемента, если он уже существовал.

Для доступа к компоненту итератора пары pr, возвращенной этой функцией-членом, используйте pr.first и разыменуйте ее с помощью *(pr.first). Для доступа к компоненту bool пары pr, возвращенной этой функцией-членом, используйте pr.second.

Замечания

Эта функция не делает недействительными никакие итераторы или ссылки.

Во время вставки, если исключение создается, но не происходит в хэш-функции контейнера, контейнер не изменяется. Если исключение вызывается в хэш-функции, результат не определен.

Пример кода см. в разделе set::emplace.

`emplace_hint`

Вставляет созданный элемент на место (операции копирования или перемещения не выполняются) с указанием о размещении.

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

Параметры

args
Аргументы, пересылаемые для создания элемента, вставляемого в unordered_set нее, если unordered_set он уже не содержит этот элемент или, как правило, если он уже не содержит элемент, ключ которого эквивалентно упорядочен.

where
Указание о месте для начала поиска правильной точки вставки.

Возвращаемое значение

Итератор, указывающий на вновь вставленный элемент.

Если не удалось вставить элемент, так как он уже существует, возвращается итератор на существующий элемент.

Замечания

Эта функция не делает недействительными никакие итераторы или ссылки.

Пример кода см. в разделе set::emplace_hint.

`empty`

Проверяет отсутствие элементов.

bool empty() const;

Замечания

Эта функция-член возвращает значение true для пустой управляемой последовательности.

Пример

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

Задает конец управляемой последовательности.

iterator end();

const_iterator end() const;

local_iterator end(size_type nbucket);

const_local_iterator end(size_type nbucket) const;

Параметры

nbucket
Номер сегмента.

Замечания

Первые две функции-члены возвращают прямой итератор, указывающий на место сразу за концом последовательности. Последние две функции-члены возвращают прямой итератор, указывающий на место сразу за концом сегмента nbucket.

Пример

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

Находит диапазон, соответствующий указанному ключу.

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

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

Параметры

keyval
Искомое значение ключа.

Замечания

Функция-член возвращает пару итераторов X , таких, что [X.first, X.second) отделяет только те элементы управляемой последовательности, которые имеют эквивалентное упорядочение с keyval. Если таких элементов не существует, оба итератора имеют значение end().

Пример

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

Удаляет элемент или диапазон элементов в unordered_set с заданных позиций или удаляет элементы, соответствующие заданному ключу.

iterator erase(const_iterator Where);

iterator erase(const_iterator First, const_iterator Last);

size_type erase(const key_type& Key);

Параметры

Where
Положение удаляемого элемента.

First
Положение первого удаляемого элемента.

Last
Позиция после последнего элемента для удаления.

Key
Значение ключа удаляемых элементов.

Возвращаемое значение

Для первых двух функций-членов двунаправленный итератор, указывающий первый элемент, оставшийся за пределами удаленных элементов, или элемент, который является концом unordered_set такого элемента, если такой элемент не существует.

Для третьей функции-члена возвращает количество элементов, которые были удалены из элемента unordered_set.

Замечания

Пример кода см. в разделе set::erase.

`find`

Определяет элемент, соответствующий указанному ключу.

const_iterator find(const Key& keyval) const;

Параметры

keyval
Искомое значение ключа.

Замечания

Функция-член возвращает значение unordered_set::equal_range(keyval).first.

Пример

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

Возвращает сохраненный объект распределителя.

Alloc get_allocator() const;

Замечания

Функция-член возвращает сохраненный объект распределителя.

Пример

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

Получает сохраненный объект хэш-функции.

Hash hash_function() const;

Замечания

Функция-член возвращает сохраненный объект хэш-функции.

Пример

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

Тип хэш-функции.

typedef Hash hasher;

Замечания

Этот тип является синонимом для параметра шаблона Hash.

Пример

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

Вставляет элемент или диапазон элементов в объект 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);

Параметры

Val
Значение элемента, вставляемого в unordered_set элемент, если он еще не содержит элемент, ключ которого эквивалентно упорядочен.

Where
Место начала поиска правильной точки вставки.

ValTy
Параметр шаблона, указывающий тип аргумента, который unordered_set можно использовать для создания элемента value_typeи идеальной пересылки Val в качестве аргумента.

First
Позиция первого элемента, который следует скопировать.

Last
Позиция непосредственно перед последним элементом, который следует скопировать.

InputIterator
Аргумент функции шаблона, соответствующий требованиям входного итератора , который указывает на элементы типа, который можно использовать для создания value_type объектов.

IList
Объект initializer_list , из которого нужно скопировать элементы.

Возвращаемое значение

Функции-члены с одним элементом (1) и (2) возвращают pair компонент, компонент которого bool имеет значение true, если вставка была выполнена, и значение false, если unordered_set элемент уже содержал элемент, ключ которого имел эквивалентное значение в порядке. Компонент итератора пары возвращаемого значения указывает на только что вставленный элемент, если bool компонент имеет trueзначение, или существующий элемент, если bool компонент является false.

Функции-члены с одним элементом с указанием (3) и (4) возвращают итератор, указывающий на позицию, в которой новый элемент был вставлен в unordered_set элемент или, если элемент с эквивалентным ключом уже существует, к существующему элементу.

Замечания

Эта функция не делает никакие итераторы, указатели или ссылки недействительными.

Во время вставки только одного элемента, если исключение возникает, но не происходит в хэш-функции контейнера, состояние контейнера не изменяется. Если исключение вызывается в хэш-функции, результат не определен. Если во время вставки нескольких элементов вызывается исключение, контейнер остается в неопределенном, но допустимом состоянии.

Чтобы получить доступ к компоненту итератора, pairpr возвращаемого функциями-элементами одного элемента, используйте ; pr.firstдля расшифровки итератора в возвращаемой паре, используйте*pr.first, предоставив элемент. Для доступа к компоненту bool используйте pr.second. См. пример кода далее в этой статье.

Контейнер value_type является типом, который принадлежит контейнеру, а для набора unordered_set<V>::value_type — тип const V.

Функция-член диапазона (5) вставляет последовательность значений unordered_set элементов в элемент, соответствующий каждому элементу, адресуемого итератором в диапазоне [First, Last), Last поэтому не вставляется. Контейнер функции-члена end() ссылается на позицию сразу после последнего элемента в контейнере. Например, оператор s.insert(v.begin(), v.end()); пытается вставить все элементы v в s. Вставляются только элементы с уникальными значениями в диапазоне. Повторяющиеся значения игнорируются. Чтобы увидеть, какие элементы отклонены, используйте одноэлементные версии insert.

Функция-член списка инициализатора (6) использует initializer_list для копирования элементов в элемент unordered_set.

Для вставки элемента, созданного на месте, то есть операции копирования или перемещения не выполняются, см set::emplace . и set::emplace_hint.

Пример кода см. в разделе set::insert.

`iterator`

Тип, предоставляющий итератор постоянной пересылки, который может считывать элементы в unordered_set.

typedef implementation-defined iterator;

Пример

Пример объявления и использования итератора см. в примереbegin.

`key_eq`

Получает сохраненный объект функции сравнения.

Pred key_eq() const;

Замечания

Функция-член возвращает сохраненный объект функции сравнения.

Пример

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

Тип функции сравнения.

typedef Pred key_equal;

Замечания

Этот тип является синонимом для параметра шаблона Pred.

Пример

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

Тип ключа упорядочения.

typedef Key key_type;

Замечания

Этот тип является синонимом для параметра шаблона Key.

Пример

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

Подсчитывает среднее число элементов в блоке.

float load_factor() const;

Замечания

Функция-член возвращает (float)unordered_set::size() / (float)unordered_set::bucket_count(), среднее количество элементов на блок.

Пример

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

Тип итератора контейнера.

typedef T4 local_iterator;

Замечания

Этот тип описывает объект, который можно использовать в качестве прямого итератора для контейнера. Здесь описано как синоним определенного реализацией типа T4.

Пример

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

Получает максимальное количество блоков.

size_type max_bucket_count() const;

Замечания

Функция-член возвращает максимальное количество блоков, которое разрешено в настоящее время.

Пример

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

Возвращает или задает максимальное количество элементов в блоке.

float max_load_factor() const;

void max_load_factor(float factor);

Параметры

factor
Новый коэффициент максимальной нагрузки.

Замечания

Первая функция-член возвращает сохраненный коэффициент максимальной нагрузки. Вторая функция-член заменяет сохраненный коэффициент максимальной нагрузки factor.

Пример

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

Возвращает максимальный размер управляемой последовательности.

size_type max_size() const;

Замечания

Функция-член возвращает длину самой длинной последовательности, которой объект может управлять.

Пример

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

Копирует хэш-таблицу.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Параметры

right
Копируемый unordered_set в .unordered_set

Замечания

После удаления всех существующих элементов в объекте unordered_setoperator= копирует или перемещает содержимое right в объект unordered_set.

Пример

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

Тип указателя на элемент.

typedef Alloc::pointer pointer;

Замечания

Этот тип описывает объект, который можно использовать в качестве указателя на элемент управляемой последовательности.

Пример

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

Тип ссылки на элемент.

typedef Alloc::reference reference;

Замечания

Тип описывает объект, который можно использовать в качестве ссылки на элемент управляемой последовательности.

Пример

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

Повторно создает хэш-таблицу.

void rehash(size_type nbuckets);

Параметры

nbuckets
Требуемое число сегментов.

Замечания

Функция-член устанавливает число сегментов не менее nbuckets и при необходимости перестраивает хэш-таблицу.

Пример

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

Подсчитывает количество элементов.

size_type size() const;

Замечания

Функция-член возвращает длину управляемой последовательности.

Пример

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

Тип беззнакового расстояния между двумя элементами.

typedef T2 size_type;

Замечания

Целочисленный тип без знака описывает объект, который может представлять длину любой управляемой последовательности. Здесь описано как синоним определенного реализацией типа T2.

Пример

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

Меняет местами содержимое двух контейнеров.

void swap(unordered_set& right);

Параметры

right
Контейнер для замены.

Замечания

Функция-член меняет местами управляемые последовательности между *this и right. Если unordered_set::get_allocator() == right.get_allocator()он делает это в постоянном времени, он создает исключение только в результате копирования объекта хранящихся признаков типа Tr, и он не допускает ссылок, указателей или итераторов, которые указывают элементы в двух управляемых последовательностях. В противном случае она выполняет ряд назначений элементов и вызовов конструктора, пропорционально количеству элементов в двух управляемых последовательностях.

Пример

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

Создает объект контейнера.

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());

Параметры

InputIterator
Тип итератора.

Al
Объект распределителя для сохранения.

Comp
Объект функции сравнения для сохранения.

Hash
Объект хэш-функции для сохранения.

bucket_count
Минимальное количество блоков.

Right
Контейнер для копирования.

IList
Содержащий initializer_list элементы для копирования.

Замечания

Первый конструктор определяет копию последовательности, управляемой Right. Второй конструктор определяет управляемую пустую последовательность. Третий конструктор задает копию последовательности, перемещая Right четвертый по восьмой конструкторы, используйте для initializer_list указания элементов для копирования. Девятый конструктор добавляет последовательность значений элементов [first, last).

Все конструкторы также инициализируют ряд сохраненных значений. Для конструктора копии значения извлекаются из элемента Right. В противном случае:

Минимальное количество контейнеров — это аргумент bucket_count, если он присутствует; в противном случае это значение по умолчанию, описанное здесь как значение N0, определяемое реализацией.

Объект хэш-функции — это аргумент Hash, если он присутствует; в противном случае — Hash()это .

Объект функции сравнения — это аргумент Comp, если он присутствует; в противном случае — Comp()значение .

Объект распределителя — это аргумент Al, если он присутствует; в противном случае — Alloc()это .

`value_type`

Тип элемента.

typedef Key value_type;

Замечания

Тип описывает элемент управляемой последовательности.

Пример

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

Класс unordered_set

Синтаксис

Параметры

Участники

Определения типов

Функции

Операторы

Замечания

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

Параметры

Класс `unordered_set`

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