hash_set (STL/CLR)

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

В приведенном ниже описании то же GKeyKey самое, что, в свою очередь, GValue совпадает с тем, что, если последний не является типом ссылок, в этом случае это Key^так.

Синтаксис

template<typename Key>
    ref class hash_set
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IHash<Gkey, GValue>
    { ..... };

Параметры

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

Требования

Заголовок:<cliext/hash_set>

Пространство именcliext:

Объявления

Определение типа Description
hash_set::const_iterator Тип постоянного итератора для управляемой последовательности.
hash_set::const_reference Тип постоянной ссылки на элемент.
hash_set::const_reverse_iterator Тип постоянного обратного итератора для управляемой последовательности.
hash_set::difference_type Тип расстояния между двумя элементами (возможно, подписанным).
hash_set::generic_container Тип универсального интерфейса для контейнера.
hash_set::generic_iterator Тип итератора универсального интерфейса для контейнера.
hash_set::generic_reverse_iterator Тип обратного итератора для универсального интерфейса контейнера.
hash_set::generic_value Тип элемента универсального интерфейса для контейнера.
hash_set::hasher Хэширование делегата ключа.
hash_set::iterator Тип итератора для управляемой последовательности.
hash_set::key_compare Делегат упорядочивания для двух ключей.
hash_set::key_type Тип ключа упорядочения.
hash_set::reference Тип ссылки на элемент.
hash_set::reverse_iterator Тип обратного итератора для управляемой последовательности.
hash_set::size_type Тип расстояния (не отрицательного) между двумя элементами.
hash_set::value_compare Делегат упорядочивания для двух значений элементов.
hash_set::value_type Тип элемента.
Функция-член Description
hash_set::begin Задает начало управляемой последовательности.
hash_set::bucket_count Подсчитывает количество контейнеров.
hash_set::clear Удаляет все элементы.
hash_set::count Подсчитывает элементы, соответствующие указанному ключу.
hash_set::empty Проверяет отсутствие элементов.
hash_set::end Задает конец управляемой последовательности.
hash_set::equal_range Находит диапазон, соответствующий указанному ключу.
hash_set::erase Удаляет элементы в указанных позициях.
hash_set::find Определяет элемент, соответствующий указанному ключу.
hash_set::hash_delegate Копирует делегат хэширования для ключа.
hash_set::hash_set Создает объект контейнера.
hash_set::insert Добавляет элементы.
hash_set::key_comp Копирует делегат упорядочивания для двух ключей.
hash_set::load_factor Подсчитывает среднее число элементов в блоке.
hash_set::lower_bound Находит начало диапазона, соответствующего указанному ключу.
hash_set::make_value Создает объект value.
hash_set::max_load_factor Возвращает или задает максимальное количество элементов в блоке.
hash_set::rbegin Задает начало обратной управляемой последовательности.
hash_set::rehash Повторно создает хэш-таблицу.
hash_set::rend Задает конец обратной управляемой последовательности.
hash_set::size Подсчитывает количество элементов.
hash_set::swap Меняет местами содержимое двух контейнеров.
hash_set::to_array Копирует контролируемую последовательность в новый массив.
hash_set::upper_bound Находит конец диапазона, соответствующий указанному ключу.
hash_set::value_comp Копирует делегат упорядочивания для двух значений элементов.
Operator Description
hash_set::operator= Заменяет управляемую последовательность.

Интерфейсы

Интерфейс Description
ICloneable Дублировать объект.
IEnumerable Последовательность элементов.
ICollection Обслуживание группы элементов.
IEnumerable<T> Последовательность с помощью типизированных элементов.
ICollection<T> Сохраняйте группу типизированных элементов.
IHash<Key, Value> Обслуживание универсального контейнера.

Замечания

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

Объект упорядочивает каждый контейнер, который он управляет, вызывая сохраненный объект делегата типа hash_set::key_compare. При создании hash_set можно указать сохраненный объект делегата; Если не указан объект делегата, по умолчанию используется сравнение operator<=(key_type, key_type).

Доступ к сохраненного объекта делегата выполняется путем вызова функции-члена hash_set::key_comp. Такой объект делегата должен определять эквивалентное упорядочение между ключами типа hash_set::key_type. Это означает, что для всех двух ключей X и Y:

key_comp()(X, Y) возвращает один и тот же логический результат для каждого вызова.

Если key_comp()(X, Y) && key_comp()(Y, X) это правда, то X и Y говорят, что имеет эквивалентный порядок.

Любое правило упорядочения, которое ведет себя как operator<=(key_type, key_type)operator>=(key_type, key_type) или operator==(key_type, key_type) определяет эквивалентный порядок.

Контейнер гарантирует, что элементы, ключи которых имеют эквивалентное упорядочение (и хэш с тем же целым значением) находятся в контейнере. В отличие от класса шаблона hash_multiset (STL/CLR), объект класса hash_set шаблона гарантирует, что ключи для всех элементов уникальны. (Нет двух ключей эквивалентного упорядочивания.)

Объект определяет, какой контейнер должен содержать заданный ключ упорядочения, вызвав сохраненный объект делегата типа hash_set::hasher. Для доступа к этому хранимой объекту вызовите функцию-член hash_set::hash_delegate , чтобы получить целочисленное значение, которое зависит от значения ключа. При создании hash_set можно указать сохраненный объект делегата; Если не указан объект делегата, по умолчанию используется функция System::Object::hash_value(key_type). Это означает, что для всех ключей X и Y:

hash_delegate()(X) возвращает один и тот же целочисленный результат для каждого вызова.

Если X и имеет эквивалентный порядок, то hash_delegate()(X) должен возвращать тот же результат целочисленного значения, что hash_delegate()(Y)и Y .

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

Если хэшированные значения не распределены равномерно, однако хэш-таблица может вырождение. В крайнем случае (для хэш-функции, которая всегда возвращает одно и то же значение), подстановка, вставка и удаление пропорциональны количеству элементов последовательности (линейное время). Контейнер стремится выбрать разумную хэш-функцию, средний размер контейнера и размер хэш-таблицы (общее количество контейнеров), но вы можете переопределить любой или все из этих вариантов. См. примеры функций hash_set::max_load_factor и hash_set::rehash.

Поддерживает hash_set двунаправленные итераторы, что означает, что можно переходить к смежным элементам с учетом итератора, обозначающего элемент в управляемой последовательности. Специальный головной узел соответствует итератору, возвращаемого end(). Этот итератор можно уменьшать, чтобы достичь последнего элемента в управляемой последовательности, если он присутствует. Вы можете увеличить hash_set итератор для достижения головного узла, а затем сравнить его с равным end(). Но вы не можете разыменовать итератор, возвращенный end().

Нельзя ссылаться на элемент непосредственно с учетом его числовой hash_set позиции. Для этого требуется итератор случайного доступа.

Итератор hash_set сохраняет дескриптор на связанный hash_set узел, который, в свою очередь, сохраняет дескриптор в связанном контейнере. Итераторы можно использовать только с связанными объектами контейнеров. Итератор hash_set остается действительным до тех пор, пока связанный hash_set узел связан с некоторыми hash_set. Кроме того, допустимый итератор является деreferencable. Его можно использовать для доступа или изменения значения элемента, указанного в нем, если оно не равно end().

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

Участники

hash_set::begin

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

Синтаксис

iterator begin();

Замечания

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

Пример

// cliext_hash_set_begin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_set::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

hash_set::bucket_count

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

Синтаксис

int bucket_count();

Замечания

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

Пример

// cliext_hash_set_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_set::clear

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

Синтаксис

void clear();

Замечания

Функция-член фактически вызывает erase(begin(), end()). Используйте его, чтобы убедиться, что управляемая последовательность пуста.

Пример

// cliext_hash_set_clear.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }
a b c
size() = 0
a b
size() = 0

hash_set::const_iterator

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

Синтаксис

typedef T2 const_iterator;

Замечания

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

Пример

// cliext_hash_set_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_set::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }
a b c

hash_set::const_reference

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

Синтаксис

typedef value_type% const_reference;

Замечания

Тип описывает константную ссылку на элемент.

Пример

// cliext_hash_set_const_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_set::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_set::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }
a b c

hash_set::const_reverse_iterator

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

Синтаксис

typedef T4 const_reverse_iterator;

Замечания

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

Пример

// cliext_hash_set_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_set::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }
c b a

hash_set::count

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

Синтаксис

size_type count(key_type key);

Параметры

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

Замечания

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

Пример

// cliext_hash_set_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }
a b c
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

hash_set::difference_type

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

Синтаксис

typedef int difference_type;

Замечания

Тип описывает возможное отрицательное число элементов.

Пример

// cliext_hash_set_difference_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_set::difference_type diff = 0;
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Myhash_set::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }
a b c
end()-begin() = 3
begin()-end() = -3

hash_set::empty

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

Синтаксис

bool empty();

Замечания

Эта функция-член возвращает значение true для пустой управляемой последовательности. Это эквивалентно size() == 0. Он используется для проверки того, является ли он hash_set пустым.

Пример

// cliext_hash_set_empty.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }
a b c
size() = 3
empty() = False
size() = 0
empty() = True

hash_set::end

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

Синтаксис

iterator end();

Замечания

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

Пример

// cliext_hash_set_end.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_set::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);
    return (0);
    }
a b c
*-- --end() = b
*--end() = c

hash_set::equal_range

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

Синтаксис

cliext::pair<iterator, iterator> equal_range(key_type key);

Параметры

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

Замечания

Функция-член возвращает пару итераторов cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Он используется для определения диапазона элементов, которые в настоящее время находятся в управляемой последовательности, соответствующей указанному ключу.

Пример

// cliext_hash_set_equal_range.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
typedef Myhash_set::pair_iter_iter Pairii;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("{0} ", *pair1.first);
    System::Console::WriteLine();
    return (0);
    }
a b c
equal_range(L'x') empty = True
b

hash_set::erase

Удаляет элементы в указанных позициях.

Синтаксис

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

Параметры

first
Начало диапазона для удаления.

key
Значение ключа для удаления.

last
Конец диапазона для удаления.

where
Элемент для удаления.

Замечания

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

Вторая функция-член удаляет элементы управляемой последовательности в диапазоне [first, lastи возвращает итератор, указывающий первый элемент, оставшийся за пределами удаленных элементов, или end() если такой элемент отсутствует. Он используется для удаления нуля или нескольких смежных элементов.

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

Каждый элемент стирает время пропорционально логарифму числа элементов в управляемой последовательности.

Пример

// cliext_hash_set_erase.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.insert(L'd');
    c1.insert(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    Myhash_set::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }
a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

hash_set::find

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

Синтаксис

iterator find(key_type key);

Параметры

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

Замечания

Если по крайней мере один элемент в управляемой последовательности имеет эквивалентное упорядочение, keyфункция-член возвращает итератор, указывающий один из этих элементов; в противном случае возвращается end(). Он используется для поиска элемента в управляемой последовательности, которая соответствует указанному ключу.

Пример

// cliext_hash_set_find.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());
    System::Console::WriteLine("find {0} = {1}",
        L'b', *c1.find(L'b'));
    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }
a b c
find A = False
find b = b
find C = False

hash_set::generic_container

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

Синтаксис

typedef Microsoft::VisualC::StlClr::
    IHash<GKey, GValue>
    generic_container;

Замечания

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

Пример

// cliext_hash_set_generic_container.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_set::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(L'e');
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }
a b c
a b c
a b c d
a b c d e

hash_set::generic_iterator

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

Синтаксис

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Замечания

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

Пример

// cliext_hash_set_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_set::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_set::generic_iterator gcit = gc1->begin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }
a b c
a b c
a

hash_set::generic_reverse_iterator

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

Синтаксис

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Замечания

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

Пример

// cliext_hash_set_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_set::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_set::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }
a b c
a b c
c

hash_set::generic_value

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

Синтаксис

typedef GValue generic_value;

Замечания

Тип описывает объект типа GValue , описывающий значение хранимого элемента для использования с универсальным интерфейсом для этого класса контейнера шаблона.

Пример

// cliext_hash_set_generic_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_set::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_set::generic_iterator gcit = gc1->begin();
    Myhash_set::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }
a b c
a b c
a

hash_set::hash_delegate

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

Синтаксис

hasher^ hash_delegate();

Замечания

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

Пример

// cliext_hash_set_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }
hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_set::hash_set

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

Синтаксис

hash_set();
explicit hash_set(key_compare^ pred);
hash_set(key_compare^ pred, hasher^ hashfn);
hash_set(hash_set<Key>% right);
hash_set(hash_set<Key>^ right);
template<typename InIter>
    hash_sethash_set(InIter first, InIter last);
template<typename InIter>
    hash_set(InIter first, InIter last,
        key_compare^ pred);
template<typename InIter>
    hash_set(InIter first, InIter last,
        key_compare^ pred, hasher^ hashfn);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);
hash_set(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred, hasher^ hashfn);

Параметры

first
Начало диапазона для вставки.

hashfn
Хэш-функция для сопоставления ключей с контейнерами.

last
Конец диапазона для вставки.

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

right
Объект или диапазон для вставки.

Замечания

Конструктор:

hash_set();

инициализирует контролируемую последовательность без элементов, с предикатом key_compare()по умолчанию и хэш-функцией по умолчанию. Он используется для указания пустой управляемой последовательности по умолчанию с предикатом заказа по умолчанию и хэш-функцией.

Конструктор:

explicit hash_set(key_compare^ pred);

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

Конструктор:

hash_set(key_compare^ pred, hasher^ hashfn);

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

Конструктор:

hash_set(hash_set<Key>% right);

инициализирует контролируемую последовательность с помощью последовательности [right.begin(), right.end()с предикатом порядка по умолчанию и хэш-функцией по умолчанию. Он используется для указания начальной управляемой последовательности, которая является копией последовательности, управляемой hash_set объектом right, с предикатом по умолчанию и хэш-функцией.

Конструктор:

hash_set(hash_set<Key>^ right);

инициализирует контролируемую последовательность с помощью последовательности [right->begin(), right->end()с предикатом порядка по умолчанию и хэш-функцией по умолчанию. Он используется для указания начальной управляемой последовательности, которая является копией последовательности, управляемой hash_set объектом right, с предикатом по умолчанию и хэш-функцией.

Конструктор:

template<typename InIter> hash_set(InIter first, InIter last);

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

Конструктор:

template<typename InIter> hash_set(InIter first, InIter last, key_compare^ pred);

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

Конструктор:

template<typename InIter> hash_set(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

инициализирует контролируемую последовательность с помощью последовательности [first, last), с предикатом predупорядочения и хэш-функцией hashfn. Он используется для создания управляемой последовательности копии другой последовательности с указанной предикатом упорядочения и хэш-функцией.

Конструктор:

hash_set(System::Collections::Generic::IEnumerable<Key>^ right);

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

Конструктор:

hash_set(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

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

Конструктор:

hash_set(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);

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

Пример

// cliext_hash_set_construct.cpp
// compile with: /clr
#include <cliext/hash_set>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
// construct an empty container
    Myhash_set c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule
    Myhash_set c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule and hash function
    Myhash_set c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_set::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

    c2h.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_set c3(c1.begin(), c1.end());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Myhash_set c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule and hash function
    Myhash_set c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_set::hasher(&myfun));
    for each (wchar_t elem in c4h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an enumeration
    Myhash_set c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Myhash_set c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c6)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule and hash function
    Myhash_set c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>(),
                gcnew Myhash_set::hasher(&myfun));
    for each (wchar_t elem in c6h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct from a generic container
    Myhash_set c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Myhash_set c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }
size() = 0
a b c
size() = 0
a b c
size() = 0
c b a

a b c
a b c
c b a

a b c
a b c
c b a

a b c
a b c

hash_set::hasher

Хэширование делегата ключа.

Синтаксис

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

Замечания

Тип описывает делегат, который преобразует значение ключа в целое число.

Пример

// cliext_hash_set_hasher.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }
hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_set::insert

Добавляет элементы.

Синтаксис

cliext::pair<iterator, bool> insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Параметры

first
Начало диапазона для вставки.

last
Конец диапазона для вставки.

right
Перечисление для вставки.

val
Значение ключа для вставки.

where
Где в контейнере для вставки (только подсказка).

Замечания

Каждая из функций-членов вставляет последовательность, указанную оставшимися операндами.

Первая функция-член пытается вставить элемент со значением valи возвращает пару значений X. Если X.second задано значение true, X.first обозначает только что вставленный элемент; в противном случае X.first обозначает элемент с эквивалентным упорядочением, который уже существует, и новый элемент не вставляется. Он используется для вставки одного элемента.

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

Третья функция-член вставляет последовательность [first, last). Он используется для вставки нуля или нескольких элементов, скопированных из другой последовательности.

Четвертая функция-член вставляет последовательность, указанную параметром right. Он используется для вставки последовательности, описанной перечислителем.

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

Пример

// cliext_hash_set_insert.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
typedef Myhash_set::pair_iter_bool Pairib;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    Pairib pair1 = c1.insert(L'x');
    System::Console::WriteLine("insert(L'x') = [{0} {1}]",
        *pair1.first, pair1.second);

    pair1 = c1.insert(L'b');
    System::Console::WriteLine("insert(L'b') = [{0} {1}]",
        *pair1.first, pair1.second);

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value with hint
    System::Console::WriteLine("insert(begin(), L'y') = {0}",
        *c1.insert(c1.begin(), L'y'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_set c2;
    Myhash_set::iterator it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_set c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }
a b c
insert(L'x') = [x True]
insert(L'b') = [b False]
a b c x
insert(begin(), L'y') = y
a b c x y
a b c x
a b c x y

hash_set::iterator

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

Синтаксис

typedef T1 iterator;

Замечания

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

Пример

// cliext_hash_set_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_set::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }
a b c

hash_set::key_comp

Копирует делегат упорядочивания для двух ключей.

Синтаксис

key_compare^key_comp();

Замечания

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

Пример

// cliext_hash_set_key_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_set c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

hash_set::key_compare

Делегат упорядочивания для двух ключей.

Синтаксис

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Замечания

Тип является синонимом делегата, который определяет порядок его ключевых аргументов.

Пример

// cliext_hash_set_key_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_set c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

hash_set::key_type

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

Синтаксис

typedef Key key_type;

Замечания

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

Пример

// cliext_hash_set_key_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using key_type
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_set::key_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }
a b c

hash_set::load_factor

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

Синтаксис

float load_factor();

Замечания

Функция-член возвращает значение (float)size() / bucket_count(). Он используется для определения среднего размера контейнера.

Пример

// cliext_hash_set_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_set::lower_bound

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

Синтаксис

iterator lower_bound(key_type key);

Параметры

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

Замечания

Функция-член определяет первый элемент X в управляемой последовательности, которая хэширует в том же контейнере, что key и имеет эквивалентное упорядочивание key. Если такой элемент не существует, возвращается end(); в противном случае возвращается итератор, указывающий X. Он используется для поиска начала последовательности элементов в настоящее время в управляемой последовательности, которая соответствует указанному ключу.

Пример

// cliext_hash_set_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    System::Console::WriteLine("*lower_bound(L'a') = {0}",
        *c1.lower_bound(L'a'));
    System::Console::WriteLine("*lower_bound(L'b') = {0}",
        *c1.lower_bound(L'b'));
    return (0);
    }
a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b

hash_set::make_value

Создает объект value.

Синтаксис

static value_type make_value(key_type key);

Параметры

key
Значение ключа для использования.

Замечания

Функция-член возвращает value_type объект, ключ которого является key. Он используется для создания объекта, подходящего для использования с несколькими другими функциями-членами.

Пример

// cliext_hash_set_make_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(Myhash_set::make_value(L'a'));
    c1.insert(Myhash_set::make_value(L'b'));
    c1.insert(Myhash_set::make_value(L'c'));

    // display contents " a b c"
    for each (Myhash_set::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }
a b c

hash_set::max_load_factor

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

Синтаксис

float max_load_factor();
void max_load_factor(float new_factor);

Параметры

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

Замечания

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

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

Пример

// cliext_hash_set_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

hash_set::operator=

Заменяет управляемую последовательность.

Синтаксис

hash_set<Key>% operator=(hash_set<Key>% right);

Параметры

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

Замечания

Оператор-член копирует right в объект, а затем возвращает *this. Он позволяет заменить управляемую последовательность копией управляемой последовательности в right.

Пример

// cliext_hash_set_operator_as.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (Myhash_set::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_set c2;
    c2 = c1;
// display contents " a b c"
    for each (Myhash_set::value_type elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }
a b c
a b c

hash_set::rbegin

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

Синтаксис

reverse_iterator rbegin();

Замечания

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

Пример

// cliext_hash_set_rbegin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_set::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);
    return (0);
    }
a b c
*rbegin() = c
*++rbegin() = b

hash_set::reference

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

Синтаксис

typedef value_type% reference;

Замечания

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

Пример

// cliext_hash_set_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_set::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_set::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }
a b c

hash_set::rehash

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

Синтаксис

void rehash();

Замечания

Функция-член перестраивает хэш-таблицу, обеспечивая это load_factor() <= max_load_factor(). В противном случае хэш-таблица увеличивается только по мере необходимости после вставки. (Он никогда не уменьшается автоматически.) Он используется для настройки размера хэш-таблицы.

Пример

// cliext_hash_set_rehash.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }
a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_set::rend

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

Синтаксис

reverse_iterator rend();

Замечания

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

Пример

// cliext_hash_set_rend.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_set::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);
    return (0);
    }
a b c
*-- --rend() = b
*--rend() = a

hash_set::reverse_iterator

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

Синтаксис

typedef T3 reverse_iterator;

Замечания

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

Пример

// cliext_hash_set_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_set::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }
c b a

hash_set::size

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

Синтаксис

size_type size();

Замечания

Функция-член возвращает длину управляемой последовательности. Он используется для определения количества элементов в текущей управляемой последовательности. Если все, что вам нужно, заключается в том, имеет ли последовательность ненулевое значение, см empty(). раздел .

Пример

// cliext_hash_set_size.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }
a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

hash_set::size_type

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

Синтаксис

typedef int size_type;

Замечания

Тип описывает число элементов, не являющихся отрицательными.

Пример

// cliext_hash_set_size_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_set::size_type diff = 0;
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }
a b c
end()-begin() = 3

hash_set::swap

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

Синтаксис

void swap(hash_set<Key>% right);

Параметры

right
Контейнер для обмена содержимым.

Замечания

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

Пример

// cliext_hash_set_swap.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_set c2;
    c2.insert(L'd');
    c2.insert(L'e');
    c2.insert(L'f');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }
a b c
d e f
d e f
a b c

hash_set::to_array

Копирует контролируемую последовательность в новый массив.

Синтаксис

cli::array<value_type>^ to_array();

Замечания

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

Пример

// cliext_hash_set_to_array.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }
a b c d
a b c

hash_set::upper_bound

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

Синтаксис

iterator upper_bound(key_type key);

Параметры

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

Замечания

Функция-член определяет последний элемент X в управляемой последовательности, которая хэширует в том же контейнере, что key и имеет эквивалентное упорядочивание key. Если такой элемент отсутствует или X является последним элементом в управляемой последовательности, он возвращается end(); в противном случае возвращается итератор, указывающий первый элемент за пределами X. Он используется для поиска конца последовательности элементов в настоящее время в управляемой последовательности, которая соответствует указанному ключу.

Пример

// cliext_hash_set_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    System::Console::WriteLine("*upper_bound(L'a') = {0}",
        *c1.upper_bound(L'a'));
    System::Console::WriteLine("*upper_bound(L'b') = {0}",
        *c1.upper_bound(L'b'));
    return (0);
    }
a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c

hash_set::value_comp

Копирует делегат упорядочивания для двух значений элементов.

Синтаксис

value_compare^ value_comp();

Замечания

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

Пример

// cliext_hash_set_value_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

hash_set::value_compare

Делегат упорядочивания для двух значений элементов.

Синтаксис

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Замечания

Тип является синонимом делегата, который определяет порядок его аргументов значений.

Пример

// cliext_hash_set_value_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    Myhash_set::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }
compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

hash_set::value_type

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

Синтаксис

typedef generic_value value_type;

Замечания

Тип является синонимом generic_value.

Пример

// cliext_hash_set_value_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_set<wchar_t> Myhash_set;
int main()
    {
    Myhash_set c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using value_type
    for (Myhash_set::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_set::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }
a b c