hash_map (STL/CLR)

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

В приведенном ниже описании то же самое, GValue что и в следующем:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

где:

GKey то же Key самое, что и если последний не является типом ссылок, в этом случае это Key^

GMapped то же Mapped самое, что и если последний не является типом ссылок, в этом случае это Mapped^

Синтаксис

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

Параметры

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

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

Требования

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

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

Объявления

Определение типа	Description
hash_map::const_iterator	Тип постоянного итератора для управляемой последовательности.
hash_map::const_reference	Тип постоянной ссылки на элемент.
hash_map::const_reverse_iterator	Тип постоянного обратного итератора для управляемой последовательности.
hash_map::difference_type	Тип расстояния между двумя элементами (возможно, подписанным).
hash_map::generic_container	Тип универсального интерфейса для контейнера.
hash_map::generic_iterator	Тип итератора универсального интерфейса для контейнера.
hash_map::generic_reverse_iterator	Тип обратного итератора для универсального интерфейса контейнера.
hash_map::generic_value	Тип элемента универсального интерфейса для контейнера.
hash_map::hasher	Хэширование делегата ключа.
hash_map::iterator	Тип итератора для управляемой последовательности.
hash_map::key_compare	Делегат упорядочивания для двух ключей.
hash_map::key_type	Тип ключа упорядочения.
hash_map::mapped_type	Тип сопоставленного значения, связанного с каждым ключом.
hash_map::reference	Тип ссылки на элемент.
hash_map::reverse_iterator	Тип обратного итератора для управляемой последовательности.
hash_map::size_type	Тип расстояния (не отрицательного) между двумя элементами.
hash_map::value_compare	Делегат упорядочивания для двух значений элементов.
hash_map::value_type	Тип элемента.

Функция-член	Description
hash_map::begin	Задает начало управляемой последовательности.
hash_map::bucket_count	Подсчитывает количество контейнеров.
hash_map::clear	Удаляет все элементы.
hash_map::count	Подсчитывает элементы, соответствующие указанному ключу.
hash_map::empty	Проверяет отсутствие элементов.
hash_map::end	Задает конец управляемой последовательности.
hash_map::equal_range	Находит диапазон, соответствующий указанному ключу.
hash_map::erase	Удаляет элементы в указанных позициях.
hash_map::find	Определяет элемент, соответствующий указанному ключу.
hash_map::hash_delegate	Копирует делегат хэширования для ключа.
hash_map::hash_map	Создает объект контейнера.
hash_map::insert	Добавляет элементы.
hash_map::key_comp	Копирует делегат упорядочивания для двух ключей.
hash_map::load_factor	Подсчитывает среднее число элементов в блоке.
hash_map::lower_bound	Находит начало диапазона, соответствующего указанному ключу.
hash_map::make_value	Создает объект value.
hash_map::max_load_factor	Возвращает или задает максимальное количество элементов в блоке.
hash_map::rbegin	Задает начало обратной управляемой последовательности.
hash_map::rehash	Повторно создает хэш-таблицу.
hash_map::rend	Задает конец обратной управляемой последовательности.
hash_map::size	Подсчитывает количество элементов.
hash_map::swap	Меняет местами содержимое двух контейнеров.
hash_map::to_array	Копирует контролируемую последовательность в новый массив.
hash_map::upper_bound	Находит конец диапазона, соответствующий указанному ключу.
hash_map::value_comp	Копирует делегат упорядочивания для двух значений элементов.

Operator	Description
hash_map::operator=	Заменяет управляемую последовательность.
hash_map::operator[]	Сопоставляет ключ с соответствующим сопоставленным значением.

Интерфейсы

Интерфейс	Description
ICloneable	Дублировать объект.
IEnumerable	Последовательность элементов.
ICollection	Обслуживание группы элементов.
IEnumerable<T>	Последовательность с помощью типизированных элементов.
ICollection<T>	Сохраняйте группу типизированных элементов.
IDictionary<TKey,TValue>	Сохраняйте группу пар {key, value}.
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_multimaphash_map шаблона гарантирует, что ключи для всех элементов уникальны. (Нет двух ключей эквивалентного упорядочивания.)

Объект определяет, какой контейнер должен содержать заданный ключ упорядочения, вызвав сохраненный объект делегата типа 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_map двунаправленные итераторы, что означает, что можно переходить к смежным элементам с учетом итератора, обозначающего элемент в управляемой последовательности. Специальный головной узел соответствует итератору, возвращаемого end(). Этот итератор можно уменьшать, чтобы достичь последнего элемента в управляемой последовательности, если он присутствует. Вы можете увеличить hash_map итератор для достижения головного узла, а затем сравнить его с равным end(). Но вы не можете разыменовать итератор, возвращенный end().

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

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

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

Участники

hash_map::begin

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

Синтаксис

iterator begin();

Замечания

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

Пример

// cliext_hash_map_begin.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_map::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*++begin() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*begin() = [a 1]
*++begin() = [b 2]

hash_map::bucket_count

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

Синтаксис

int bucket_count();

Замечания

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

Пример

// cliext_hash_map_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1 = gcnew Myhash_map;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    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 1] [b 2] [c 3]
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_map::clear

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

Синтаксис

void clear();

Замечания

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

Пример

// cliext_hash_map_clear.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

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

hash_map::const_iterator

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

Синтаксис

typedef T2 const_iterator;

Замечания

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

Пример

// cliext_hash_map_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("[{0} {1}] ", cit->first, cit->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::const_reference

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

Синтаксис

typedef value_type% const_reference;

Замечания

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

Пример

// cliext_hash_map_const_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_map::const_reference cref = *cit;
        System::Console::Write("[{0} {1}] ", cref->first, cref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::const_reverse_iterator

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

Синтаксис

typedef T4 const_reverse_iterator;

Замечания

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

Пример

// cliext_hash_map_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_map::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("[{0} {1}] ", crit->first, crit->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::count

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

Синтаксис

size_type count(key_type key);

Параметры

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

Замечания

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

Пример

// cliext_hash_map_count.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    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 1] [b 2] [c 3]
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

hash_map::difference_type

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

Синтаксис

typedef int difference_type;

Замечания

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

Пример

// cliext_hash_map_difference_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

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

hash_map::empty

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

Синтаксис

bool empty();

Замечания

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

Пример

// cliext_hash_map_empty.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    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 1] [b 2] [c 3]
size() = 3
empty() = False
size() = 0
empty() = True

hash_map::end

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

Синтаксис

iterator end();

Замечания

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

Пример

// cliext_hash_map_end.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_map::iterator it = c1.end();
    --it;
    --it;
    System::Console::WriteLine("*-- --end() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*--end() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

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

hash_map::equal_range

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

Синтаксис

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

Параметры

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

Замечания

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

Пример

// cliext_hash_map_equal_range.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
typedef Myhash_map::pair_iter_iter Pairii;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    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} {1}] ",
            pair1.first->first, pair1.first->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
equal_range(L'x') empty = True
[b 2]

hash_map::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_map_erase.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    cliext::hash_map<wchar_t, int> c1;
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'a', 1));
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'b', 2));
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::hash_map<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase an element and reinspect
    cliext::hash_map<wchar_t, int>::iterator it =
        c1.erase(c1.begin());
    System::Console::WriteLine("erase(begin()) = [{0} {1}]",
        it->first, it->second);

    // add elements and display " b c d e"
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::hash_map<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase all but end
    it = c1.end();
    it = c1.erase(c1.begin(), --it);
    System::Console::WriteLine("erase(begin(), end()-1) = [{0} {1}]",
        it->first, it->second);
    System::Console::WriteLine("size() = {0}", c1.size());

    // erase end
    System::Console::WriteLine("erase(L'x') = {0}", c1.erase(L'x'));
    System::Console::WriteLine("erase(L'e') = {0}", c1.erase(L'e'));
    return (0);
    }

[a 1] [b 2] [c 3]
erase(begin()) = [b 2]
[b 2] [c 3] [d 4] [e 5]
erase(begin(), end()-1) = [e 5]
size() = 1
erase(L'x') = 0
erase(L'e') = 1

hash_map::find

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

Синтаксис

iterator find(key_type key);

Параметры

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

Замечания

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

Пример

// cliext_hash_map_find.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());

    Myhash_map::iterator it = c1.find(L'b');
    System::Console::WriteLine("find {0} = [{1} {2}]",
        L'b', it->first, it->second);

    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

[a 1] [b 2] [c 3]
find A = False
find b = [b 2]
find C = False

hash_map::generic_container

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

Синтаксис

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

Замечания

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

Пример

// cliext_hash_map_generic_container.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(Myhash_map::make_value(L'd', 4));
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(Myhash_map::make_value(L'e', 5));
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::generic_iterator

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

Синтаксис

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

Замечания

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

Пример

// cliext_hash_map_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_map::generic_iterator gcit = gc1->begin();
    Myhash_map::generic_value gcval = *gcit;
    System::Console::Write("[{0} {1}] ", gcval->first, gcval->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::generic_reverse_iterator

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

Синтаксис

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

Замечания

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

Пример

// cliext_hash_map_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_map::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_map::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

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

hash_map::generic_value

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

Синтаксис

typedef GValue generic_value;

Замечания

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

Пример

// cliext_hash_map_generic_value.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_map::generic_iterator gcit = gc1->begin();
    Myhash_map::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

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

hash_map::hash_delegate

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

Синтаксис

hasher^ hash_delegate();

Замечания

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

Пример

// cliext_hash_map_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::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_map::hash_map

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

Синтаксис

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

Параметры

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

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

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

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

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

Замечания

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

hash_map();

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

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

explicit hash_map(key_compare^ pred);

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

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

hash_map(key_compare^ pred, hasher^ hashfn);

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

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

hash_map(hash_map<Key, Mapped>% right);

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

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

hash_map(hash_map<Key, Mapped>^ right);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример

// cliext_hash_map_construct.cpp
// compile with: /clr
#include <cliext/hash_map>

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

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

    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    c2.insert(c1.begin(), c1.end());
    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    c2h.insert(c1.begin(), c1.end());
    for each (Myhash_map::value_type elem in c2h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_map c3(c1.begin(), c1.end());
    for each (Myhash_map::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

    // construct with an enumeration
    Myhash_map c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_map::value_type>^)%c3);
    for each (Myhash_map::value_type elem in c5)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

    // construct by copying another container
    Myhash_map c7(c4);
    for each (Myhash_map::value_type elem in c7)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying a container handle
    Myhash_map c8(%c3);
    for each (Myhash_map::value_type elem in c8)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

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

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

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

hash_map::hasher

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

Синтаксис

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

Замечания

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

Пример

// cliext_hash_map_hasher.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::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_map::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_map_insert.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
typedef Myhash_map::pair_iter_bool Pairib;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value with hint
    Myhash_map::iterator it =
        c1.insert(c1.begin(), Myhash_map::make_value(L'y', 25));
    System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
        it->first, it->second);
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_map c2;
    it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_map c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Myhash_map::value_type>^)%c1);
    for each (Myhash_map::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
insert([L'x' 24]) = [x 24] True
insert([L'b' 2]) = [b 2] False
[a 1] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [c 3] [x 24]
[a 1] [b 2] [c 3] [x 24] [y 25]

hash_map::iterator

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

Синтаксис

typedef T1 iterator;

Замечания

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

Пример

// cliext_hash_map_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("[{0} {1}] ", it->first, it->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::key_comp

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

Синтаксис

key_compare^key_comp();

Замечания

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

Пример

// cliext_hash_map_key_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::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_map 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_map::key_compare

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

Синтаксис

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

Замечания

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

Пример

// cliext_hash_map_key_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::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_map 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_map::key_type

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

Синтаксис

typedef Key key_type;

Замечания

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

Пример

// cliext_hash_map_key_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using key_type
    for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_map::key_type val = it->first;

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

a b c

hash_map::load_factor

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

Синтаксис

float load_factor();

Замечания

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

Пример

// cliext_hash_map_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1 = gcnew Myhash_map;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    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 1] [b 2] [c 3]
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_map::lower_bound

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

Синтаксис

iterator lower_bound(key_type key);

Параметры

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

Замечания

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

Пример

// cliext_hash_map_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    Myhash_map::iterator it = c1.lower_bound(L'a');
    System::Console::WriteLine("*lower_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.lower_bound(L'b');
    System::Console::WriteLine("*lower_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
lower_bound(L'x')==end() = True
*lower_bound(L'a') = [a 1]
*lower_bound(L'b') = [b 2]

hash_map::make_value

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

Синтаксис

static value_type make_value(key_type key, mapped_type mapped);

Параметры

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

mapped
Сопоставленное значение для поиска.

Замечания

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

Пример

// cliext_hash_map_make_value.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::mapped_type

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

Синтаксис

typedef Mapped mapped_type;

Замечания

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

Пример

// cliext_hash_map_mapped_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using mapped_type
    for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in mapped_type object
        Myhash_map::mapped_type val = it->second;

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

1 2 3

hash_map::max_load_factor

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

Синтаксис

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

Параметры

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

Замечания

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

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

Пример

// cliext_hash_map_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1 = gcnew Myhash_map;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    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 1] [b 2] [c 3]
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_map::operator=

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

Синтаксис

hash_map<Key, Mapped>% operator=(hash_map<Key, Mapped>% right);

Параметры

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

Замечания

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

Пример

// cliext_hash_map_operator_as.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_map c2;
    c2 = c1;
// display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::operator[]

Сопоставляет ключ с соответствующим сопоставленным значением.

Синтаксис

mapped_type operator[](key_type key);

Параметры

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

Замечания

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

Пример

// cliext_hash_map_operator_sub.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("c1[{0}] = {1}",
        L'A', c1[L'A']);
    System::Console::WriteLine("c1[{0}] = {1}",
        L'b', c1[L'b']);

    // redisplay altered contents
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // alter mapped values and redisplay
    c1[L'A'] = 10;
    c1[L'c'] = 13;
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
c1[A] = 0
c1[b] = 2
[a 1] [A 0] [b 2] [c 3]
[a 1] [A 10] [b 2] [c 13]

hash_map::rbegin

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

Синтаксис

reverse_iterator rbegin();

Замечания

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

Пример

// cliext_hash_map_rbegin.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_map::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*++rbegin() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*rbegin() = [c 3]
*++rbegin() = [b 2]

hash_map::reference

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

Синтаксис

typedef value_type% reference;

Замечания

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

Пример

// cliext_hash_map_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_map::reference ref = *it;
        System::Console::Write("[{0} {1}] ", ref->first, ref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::rehash

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

Синтаксис

void rehash();

Замечания

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

Пример

// cliext_hash_map_rehash.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1 = gcnew Myhash_map;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    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 1] [b 2] [c 3]
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_map::rend

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

Синтаксис

reverse_iterator rend();

Замечания

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

Пример

// cliext_hash_map_rend.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_map::reverse_iterator rit = c1.rend();
    --rit;
    --rit;
    System::Console::WriteLine("*-- --rend() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*--rend() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*-- --rend() = [b 2]
*--rend() = [a 1]

hash_map::reverse_iterator

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

Синтаксис

typedef T3 reverse_iterator;

Замечания

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

Пример

// cliext_hash_map_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_map::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("[{0} {1}] ", rit->first, rit->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::size

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

Синтаксис

size_type size();

Замечания

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

Пример

// cliext_hash_map_size.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    // add elements and clear again
    c1.insert(Myhash_map::make_value(L'd', 4));
    c1.insert(Myhash_map::make_value(L'e', 5));
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0 after clearing
size() = 2 after adding 2

hash_map::size_type

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

Синтаксис

typedef int size_type;

Замечания

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

Пример

// cliext_hash_map_size_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

hash_map::swap

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

Синтаксис

void swap(hash_map<Key, Mapped>% right);

Параметры

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

Замечания

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

Пример

// cliext_hash_map_swap.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_map c2;
    c2.insert(Myhash_map::make_value(L'd', 4));
    c2.insert(Myhash_map::make_value(L'e', 5));
    c2.insert(Myhash_map::make_value(L'f', 6));
    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    for each (Myhash_map::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::to_array

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

Синтаксис

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

Замечания

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

Пример

// cliext_hash_map_to_array.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

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

    c1.insert(Myhash_map::make_value(L'd', 4));
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (Myhash_map::value_type elem in a1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_map::upper_bound

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

Синтаксис

iterator upper_bound(key_type key);

Параметры

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

Замечания

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

Пример

// cliext_hash_map_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    Myhash_map::iterator it = c1.upper_bound(L'a');
    System::Console::WriteLine("*upper_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.upper_bound(L'b');
    System::Console::WriteLine("*upper_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
upper_bound(L'x')==end() = True
*upper_bound(L'a') = [b 2]
*upper_bound(L'b') = [c 3]

hash_map::value_comp

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

Синтаксис

value_compare^ value_comp();

Замечания

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

Пример

// cliext_hash_map_value_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'b', 2),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

hash_map::value_compare

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

Синтаксис

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

Замечания

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

Пример

// cliext_hash_map_value_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'b', 2),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

hash_map::value_type

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

Синтаксис

typedef generic_value value_type;

Замечания

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

Пример

// cliext_hash_map_value_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    c1.insert(Myhash_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));
    c1.insert(Myhash_map::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using value_type
    for (Myhash_map::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_map::value_type val = *it;
        System::Console::Write("[{0} {1}] ", val->first, val->second);
        }
    System::Console::WriteLine();
    return (0);
    }

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