Класс hash_map

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

Синтаксис

template <class Key,
    class Type,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<pair <const Key, Type>>>
class hash_map

Параметры

Key
Тип данных ключа, который должен храниться в объекте hash_map.

Type
Тип данных элемента для сохранения в hash_map.

Traits
Тип, включающий два объекта функции, один из классов может сравнить два значения элементов в качестве ключей сортировки, чтобы определить их относительный порядок и хэш-функцию, которая является унарным сопоставлением ключевых значений ключей элементов с неподписанными целыми числами типа size_t. Этот аргумент является необязательным и hash_compare<Key, less<Key>> является значением по умолчанию.

Allocator
Тип, представляющий хранимый объект распределителя, инкапсулирующий сведения о hash_mapвыделении и освобождении памяти. Этот аргумент является необязательным, и в качестве значения по умолчанию используется allocator<pair <const Key, Type>>.

Замечания

Элемент hash_map:

• Ассоциативный контейнер, который является контейнером переменного размера, поддерживающим эффективное получение значений элементов на основе значения соответствующего ключа.

• Является реверсивным, поскольку предоставляет двунаправленный итератор для получения доступа к его элементам.

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

• Является уникальным, поскольку каждый его элемент должен обладать уникальным ключом.

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

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

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

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

Должен hash_map быть ассоциативный контейнер выбора, когда условия, связывающие значения с ключами, удовлетворяются приложением. Модель этого типа структуры представляет собой упорядоченный список уникальных ключевых слов со связанными строковыми значениями, предоставляющими, к примеру, определения. Если вместо этого слова имели более одного правильного определения, поэтому ключи не были уникальными, то hash_multimap будет контейнер выбора. Если, с другой стороны, хранится только список слов, то hash_set будет правильный контейнер. Если было разрешено несколько вхождений слов, hash_multiset то будет соответствующая структура контейнера.

Порядок hash_map последовательности, которую он управляет, вызывая сохраненный хэш-объект Traits класса value_compare. К этому хранимой объекту можно получить доступ, вызвав функцию-член key_comp. Такой объект функции должен вести себя так же, как объект класса hash_compare<Key, less<Key>>. В частности, для значений Key типа Key вызов Traits(Key) создает распределение значений типа size_t. Дополнительные сведения см. в разделе hash_compare.

Как правило, элементы должны быть просто меньше, чем сравнимые для установления этого порядка: чтобы, учитывая два элемента, можно определить, что они эквивалентны (в том смысле, что ни меньше другого), либо что один меньше другого. Это приводит к упорядочению неравнозначных элементов. С более технической точки зрения, функция сравнения является бинарным предикатом, который вызывает строгого слабое упорядочение в стандартном математически смысле. Бинарный предикат f(x y) является объектом-функцией, которая содержит два объекта аргументов x и y, а также возвращаемое значение true или false. Упорядочение, наложенное на a hash_map , является строгим слабым упорядочением, если двоичный предикат является irreflexive, антисимметричным и транзитивным, а если эквивалентность является транзитивной, где два объекта x и y определяются как эквивалентные, если оба f(x, y) и f(y, x) являются false. Если более строгое условие равенства между ключами заменяет условие эквивалентности, порядок становится общим (т.е. все элементы упорядочиваются относительно друг друга), и сопоставленные ключи будут неотличимы друг от друга.

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

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

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

Конструктор	Description
hash_map	Создает контейнер hash_map, который является пустым или копией части или целого другого контейнера hash_map.

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

Введите имя	Description
allocator_type	Тип, представляющий класс allocator для объекта hash_map.
const_iterator	Тип, предоставляющий двунаправленный итератор, который может считывать тот или иной элемент const в контейнере hash_map.
const_pointer	Тип, предоставляющий указатель на элемент const в контейнере hash_map.
const_reference	Тип, предоставляющий ссылку на элемент const, сохраненный в контейнере hash_map для чтения и выполнения операций const.
const_reverse_iterator	Тип, предоставляющий двунаправленный итератор, который может считывать любой элемент const в контейнере hash_map.
difference_type	Тип целого числа со знаком, пригодный для представления количества элементов в контейнере hash_map в диапазоне между элементами, на которые указывают итераторы.
iterator	Тип, предоставляющий двунаправленный итератор, который может считывать или изменять любой элемент в hash_map.
key_compare	Тип, предоставляющий объект функции, который может сравнить два ключа сортировки для определения относительного порядка двух элементов в контейнере hash_map.
key_type	Тип описывает объект ключа сортировки, составляющий каждый элемент hash_map.
mapped_type	Тип, который представляет тип данных, хранящийся в контейнере hash_map.
pointer	Тип, предоставляющий указатель на элемент в hash_map.
reference	Тип, предоставляющий ссылку на элемент, хранящийся в контейнере hash_map.
reverse_iterator	Тип, предоставляющий двунаправленный итератор, который может считывать или изменять элемент в обращенном контейнере hash_map.
size_type	Целочисленный Typedef без знака, который может представлять число элементов в hash_map.
value_type	Тип, предоставляющий объект функции, который может сравнить два элемента в качестве ключей сортировки для определения их относительного порядка в контейнере hash_map.

Функции элементов

Функция-член	Description
at	Находит элемент в hash_map с указанным значением ключа.
begin	Возвращает итератор, обращающийся к первый элемент в контейнере hash_map.
cbegin	Возвращает итератор const, обращающийся к первому элементу в hash_map.
cend	Возвращает итератор const, который обращается к месту, следующему за последним элементом в hash_map.
clear	Стирает все элементы в hash_map.
count	Возвращает число элементов в контейнере hash_map, ключи которых соответствуют ключу, заданному параметром.
crbegin	Возвращает итератор, обращаюющийся к первому const элементу в обратном hash_mapнаправлении.
crend	const Возвращает итератор, который обращается к расположению, успешному последнему элементу в обратномhash_map.
emplace	Вставляет созданный на месте элемент в hash_map.
emplace_hint	Вставляет созданный на месте элемент в hash_map с подсказкой о размещении.
empty	Проверяет, пуст ли hash_map.
end	Возвращает итератор, который обращается к месту, следующему за последним элементом в контейнере hash_map.
equal_range	Возвращает пару итераторов соответственно на первый элемент в наборе hash_map с ключом, который больше, чем указанный ключ, и на первый элемент в наборе hash_map с ключом, который больше или равен данному ключу.
erase	Удаляет элемент или диапазон элементов с указанных положений в hash_map.
find	Возвращает итератор, адресующий расположение элемента в наборе hash_map с ключом, эквивалентным указанному ключу.
get_allocator	Возвращает копию объекта allocator, который используется для создания контейнера hash_map.
insert	Вставляет элемент или диапазон элементов в hash_map.
key_comp	Возвращает итератор, указывающий на первый элемент в hash_map с ключом, который больше или равен указанному ключу.
lower_bound	Возвращает итератор, указывающий на первый элемент в hash_map с ключом, который больше или равен указанному ключу.
max_size	Возвращает максимальную длину hash_map.
rbegin	Возвращает итератор, который обращается к первому элементу в обращенном контейнере hash_map.
rend	Возвращает итератор, который обращается к месту, следующему за последним элементом в обращенном контейнере hash_map.
size	Возвращает количество элементов в контейнере hash_map.
swap	Выполняет обмен элементами между двумя объектами hash_map.
upper_bound	Возвращает итератор, указывающий на первый элемент в hash_map со значением ключа, которое больше указанного ключа.
value_comp	Извлекает копию объекта сравнения, который используется для упорядочивания значений элементов в наборе hash_map.

Операторы

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

Требования

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

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

hash_map::allocator_type

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Тип, представляющий класс распределителя для объекта hash_map.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

Пример

Пример использования allocator_typeсм. в примереget_allocator.

hash_map::at

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Находит элемент в hash_map с указанным значением ключа.

Type& at(const Key& key);

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

Параметры

key
Значение ключа элемента, который требуется найти.

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

Ссылка на значение данных найденного элемента.

Замечания

Если значение ключа аргумента не найдено, функция создает объект класса Classout_of_range.

Пример

// hash_map_at.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;

   // Insert data values
   hm1.insert ( cInt2Int ( 1, 10 ) );
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The values of the mapped elements are:";
   for ( int i = 1 ; i <= hm1.size() ; i++ )
      cout << " " << hm1.at(i);
   cout << "." << endl;
}

hash_map::begin

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

const_iterator begin() const;

iterator begin();

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

Двунаправленный итератор, обращаюющийся к первому элементу в hash_map расположении, успешно hash_mapпустому.

Пример

// hash_map_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 0, 0 ) );
   hm1.insert ( Int_Pair ( 1, 1 ) );
   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.begin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;

   hm1_Iter = hm1.begin ( );
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.begin ( );
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.begin( );
   cout << "The first element of hm1 is now "
        << hm1_cIter -> first << "." << endl;
}

The first element of hm1 is 0.
The first element of hm1 is now 1.

hash_map::cbegin

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

const_iterator cbegin() const;

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

Констант двунаправленный итератор, обращаюющийся к первому элементу в hash_map расположении, успешно пустому hash_map.

Пример

// hash_map_cbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.cbegin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;
   }

The first element of hm1 is 2.

hash_map::cend

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

const_iterator cend() const;

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

Двунаправленный итератор константы, который обращается к расположению, успешному последнему элементу в объекте hash_map. Если hash_map является пустым, то hash_map::cend == hash_map::begin.

Замечания

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

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

Пример

// hash_map_cend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.cend( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;
   }

The value of last element of hm1 is 30.

hash_map::clear

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Стирает все элементы в hash_map.

void clear();

Замечания

Пример

В следующем примере показано использование hash_map::clear функции-члена.

// hash_map_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    hm1.insert(Int_Pair(2, 4));

    i = hm1.size();
    cout << "The size of the hash_map is initially "
         << i << "." << endl;

    hm1.clear();
    i = hm1.size();
    cout << "The size of the hash_map after clearing is "
         << i << "." << endl;
}

The size of the hash_map is initially 2.
The size of the hash_map after clearing is 0.

hash_map::const_iterator

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

Замечания

Тип const_iterator нельзя использовать для изменения значения элемента.

Определяется const_iterator hash_map элементами, которые являются объектами value_typeтипа , pair< const Key, Type >чей первый член является ключом к элементу и чей второй член является сопоставленным datum, удерживаемым элементом.

Чтобы разыменовать const_iterator cIter элемент в элементе hash_map, используйте -> оператор.

Чтобы получить доступ к значению ключа для элемента, используйте cIter->first, что эквивалентно (*cIter).first. Чтобы получить доступ к значению сопоставленной datum для элемента, используйте cIter->secondэквивалент (*cIter).second.

Пример

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

hash_map::const_pointer

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;

Замечания

Тип const_pointer нельзя использовать для изменения значения элемента.

В большинстве случаев iterator необходимо использовать для доступа к элементам в объекте hash_map .

hash_map::const_reference

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;

Замечания

Пример

// hash_map_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of the first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of the first element in the hash_map is "
        << Ref2 << "." << endl;
}

The key of the first element in the hash_map is 1.
The data value of the first element in the hash_map is 10.

hash_map::const_reverse_iterator

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse)iterator const_reverse_iterator;

Замечания

Тип const_reverse_iterator не может изменить значение элемента и используется для итерации с помощью обратного hash_map элемента.

Определяется const_reverse_iterator hash_map элементами, которые являются объектами value_typeтипа , pair< const Key, Type >чей первый член является ключом к элементу и чей второй член является сопоставленным datum, удерживаемым элементом.

Чтобы разыменовать const_reverse_iterator crIter элемент в элементе hash_map, используйте -> оператор.

Чтобы получить доступ к значению ключа для элемента, используйте crIter->first, что эквивалентно (*crIter).first. Чтобы получить доступ к значению сопоставленной datum для элемента, используйте crIter->secondэквивалент (*crIter).first.

Пример

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

hash_map::count

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

size_type count(const Key& key) const;

Параметры

key
Ключевое значение элементов, которые должны быть сопоставлены из элемента hash_map.

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

1, если элемент hash_map содержит элемент, ключ сортировки которого соответствует ключу параметра; 0, если hash_map элемент не содержит соответствующий ключ.

Замечания

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

lower_bound(key), upper_bound(key)

значение 0 или 1 в случае hash_mapс уникальным ассоциативным контейнером.

Пример

В следующем примере показано использование hash_map::count функции-члена.

// hash_map_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair (1, 1));
    hm1.insert(Int_Pair (2, 1));
    hm1.insert(Int_Pair (1, 4));
    hm1.insert(Int_Pair (2, 1));

    // Keys must be unique in hash_map, so duplicates are ignored
    i = hm1.count(1);
    cout << "The number of elements in hm1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hm1.count(2);
    cout << "The number of elements in hm1 with a sort key of 2 is: "
         << i << "." << endl;

    i = hm1.count(3);
    cout << "The number of elements in hm1 with a sort key of 3 is: "
         << i << "." << endl;
}

The number of elements in hm1 with a sort key of 1 is: 1.
The number of elements in hm1 with a sort key of 2 is: 1.
The number of elements in hm1 with a sort key of 3 is: 0.

hash_map::crbegin

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

const_reverse_iterator crbegin() const;

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

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

Замечания

crbegin используется с обратным hash_map так же, как begin используется с hash_map.

Возвращаемое значение crbeginhash_map объекта невозможно изменить.

crbegin можно использовать для перебора hash_map в обратном порядке.

Пример

// hash_map_crbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.

hash_map::crend

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

const_reverse_iterator crend() const;

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

const Обратный двунаправленный итератор, который обращается к расположению, успешному последнему элементу в обратном hash_map направлении (расположение, которое предшествовало первому элементу в непровернутомhash_map).

Замечания

crend используется с обратным hash_map так же, как hash_map::end используется с hash_map.

Возвращаемое значение crendhash_map объекта невозможно изменить.

crend используется, чтобы проверить, достиг ли итератор конца hash_map.

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

Пример

// hash_map_crend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crend( );
   hm1_crIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 3.

hash_map::difference_type

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::difference_type difference_type;

Пример

// hash_map_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 3, 20 ) );

   // The following won't insert, because map keys are unique
   hm1.insert ( Int_Pair ( 2, 30 ) );

   hash_map <int, int>::iterator hm1_Iter, hm1_bIter, hm1_eIter;
   hm1_bIter = hm1.begin( );
   hm1_eIter = hm1.end( );

   // Count the number of elements in a hash_map
   hash_map <int, int>::difference_type  df_count = 0;
   hm1_Iter = hm1.begin( );
   while ( hm1_Iter != hm1_eIter)
   {
      df_count++;
      hm1_Iter++;
   }

   cout << "The number of elements in the hash_map hm1 is: "
        << df_count << "." << endl;

   cout  << "The keys of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> second;
   cout << "." << endl;
}

The number of elements in the hash_map hm1 is: 3.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 20.

hash_map::emplace

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Вставляет созданный на месте элемент в hash_map.

template <class ValTy>
pair <iterator, bool>
emplace(
    ValTy&& val);

Параметры

val
Значение, используемое для перемещения элемента, вставляемого в hash_map элемент, если hash_map он уже не содержит этот элемент (или, как правило, элемент, ключ которого эквивалентно упорядочен).

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

emplace Функция-член возвращает пару, компонент которой bool возвращает true значение, если вставка была выполнена, и false если hash_map элемент уже содержал элемент, ключ которого имел эквивалентное значение в порядке, и компонент которого iterator возвращает адрес, в котором был вставлен новый элемент или где элемент уже расположен.

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

Замечания

Элемент hash_map::value_type является парой, поэтому значение элемента будет упорядоченной парой с первым компонентом, равным значению ключа, и второй компонент равен значению данных элемента.

Пример

// hash_map_emplace.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(move(is1));
    cout << "After the emplace insertion, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_map::emplace_hint

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

template <class ValTy>
iterator emplace_hint(
    const_iterator _Where,
    ValTy&& val);

Параметры

val
Значение, используемое для перемещения элемента, вставляемого в hash_map элемент, если hash_map он уже не содержит этот элемент (или, как правило, элемент, ключ которого эквивалентно упорядочен).

c
Подсказка о месте начала поиска правильной точки вставки.

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

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

Замечания

Элемент hash_map::value_type является парой, поэтому значение элемента будет упорядоченной парой с первым компонентом, равным значению ключа, и второй компонент равен значению данных элемента.

Вставка может происходить в амортизированном константном, а не в логарифмическом времени, если точка вставки следует сразу за _Where.

Пример

// hash_map_emplace_hint.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(hm1.begin(), move(is1));
    cout << "After the emplace, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}

After the emplace insertion, hm1 contains:
1 => a

hash_map::empty

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Проверяет, пуст ли hash_map.

bool empty() const;

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

truehash_map Значение , если hash_map значение не false является пустым.

Замечания

Пример

// hash_map_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2;

   typedef pair <int, int> Int_Pair;
   hm1.insert ( Int_Pair ( 1, 1 ) );

   if ( hm1.empty( ) )
      cout << "The hash_map hm1 is empty." << endl;
   else
      cout << "The hash_map hm1 is not empty." << endl;

   if ( hm2.empty( ) )
      cout << "The hash_map hm2 is empty." << endl;
   else
      cout << "The hash_map hm2 is not empty." << endl;
}

The hash_map hm1 is not empty.
The hash_map hm2 is empty.

hash_map::end

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

const_iterator end() const;

iterator end();

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

Двунаправленный итератор, который обращается к расположению, успешному последнему элементу в объекте hash_map. Если hash_map является пустым, то hash_map::end == hash_map::begin.

Замечания

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

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

Пример

// hash_map_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;

   hm1_Iter = hm1.end( );
   hm1_Iter--;
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.end ( );
   // hm1_cIter--;
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is now "
        << hm1_cIter -> second << "." << endl;
}

The value of last element of hm1 is 30.
The value of last element of hm1 is now 20.

hash_map::equal_range

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Параметры

key
Значение ключа аргумента, которое необходимо сравнить с ключом сортировки элемента из выполняемого hash_map поиска.

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

Пара итераторов, так что первый является lower_bound ключом, а второй — upper_bound ключом.

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

Замечания

Пример

// hash_map_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_map <int, int> IntMap;
   IntMap hm1;
   hash_map <int, int> :: const_iterator hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

   cout << "The lower bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   hm1_RcIter = hm1.upper_bound( 2 );

   cout << "A direct call of upper_bound( 2 ) gives "
        << hm1_RcIter -> second << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 2 )." << endl;

   p2 = hm1.equal_range( 4 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hm1.end( ) ) && ( p2.second == hm1.end( ) ) )
      cout << "The hash_map hm1 doesn't have an element "
             << "with a key less than 40." << endl;
   else
      cout << "The element of hash_map hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2 in the hash_map hm1 is: 20.
The upper bound of the element with a key of 2 in the hash_map hm1 is: 30.
A direct call of upper_bound( 2 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 2 ).
The hash_map hm1 doesn't have an element with a key less than 40.

hash_map::erase

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Параметры

_Where
Положение элемента, который необходимо удалить из hash_mapэлемента.

first
Позиция первого элемента, удаленного из элемента hash_map.

last
Позиция только за последним элементом, удаленным из элемента hash_map.

key
Ключевое значение элементов, которые необходимо удалить из элемента hash_map.

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

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

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

Замечания

Функции-члены не создают исключений.

Пример

В следующем примере показано использование hash_map::erase функции-члена.

// hash_map_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2, hm3;
    hash_map<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_map<int, int>::size_type n;
    typedef pair<int, int> Int_Pair;

    for (i = 1; i < 5; i++)
    {
        hm1.insert(Int_Pair (i, i));
        hm2.insert(Int_Pair (i, i*i));
        hm3.insert(Int_Pair (i, i-1));
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hm1.begin();
    hm1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_map hm1 is:";
    for (pIter = hm1.begin(); pIter != hm1.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hm2.begin();
    Iter2 = --hm2.end();
    hm2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_map hm2 is:";
    for (pIter = hm2.begin(); pIter != hm2.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hm3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hm3.begin();
    hm3.erase(Iter1);

    cout << "After another element with a key equal to that"
         << endl;
    cout  << "of the 2nd element is deleted, "
          << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_map hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_map hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_map hm3 is: 0 2 3.
The number of elements removed from hm3 is: 1.
After another element with a key equal to that
of the 2nd element is deleted, the hash_map hm3 is: 0 3.

hash_map::find

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Параметры

key
Значение ключа, которое должно соответствовать ключу сортировки элемента из выполняемого hash_map поиска.

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

Итератор, который обращается к расположению элемента с указанным ключом, или расположение, успешное выполнение последнего элемента в hash_map случае, если совпадение не найдено для ключа.

Замечания

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

Если возвращаемое значение find назначено объекту const_iterator, hash_map объект нельзя изменить. Если возвращаемое значение find назначено объекту iterator, hash_map его можно изменить.

Пример

// hash_map_find.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.find( 2 );
   cout << "The element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.find( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1.find( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

hash_map::get_allocator

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Возвращает копию объекта распределителя, используемого для создания hash_mapобъекта.

Allocator get_allocator() const;

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

Распределитель, используемый параметром hash_map.

Замечания

Распределители для hash_map класса указывают, как класс управляет хранилищем. Распределители по умолчанию для классов контейнеров из стандартной библиотеки C++ достаточны для большинства задач программирования. Написание и использование собственного класса распределителя требует расширенных навыков работы с C++.

Пример

// hash_map_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int>::allocator_type hm1_Alloc;
   hash_map <int, int>::allocator_type hm2_Alloc;
   hash_map <int, double>::allocator_type hm3_Alloc;
   hash_map <int, int>::allocator_type hm4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   hash_map <int, int> hm1;
   hash_map <int, int> hm2;
   hash_map <int, double> hm3;

   hm1_Alloc = hm1.get_allocator( );
   hm2_Alloc = hm2.get_allocator( );
   hm3_Alloc = hm3.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm2.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm3.max_size( ) <<  "." << endl;

   // The following line creates a hash_map hm4
   // with the allocator of hash_map hm1.
   hash_map <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( hm1_Alloc == hm4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_map::hash_map

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Создает пустую hash_map или является копией всех или частью другого hash_map.

hash_map();

explicit hash_map(
    const Traits& Comp);

hash_map(
    const Traits& Comp,
    const Allocator& Al);

hash_map(
    const hash_map& Right);

hash_map(
    hash_map&& Right);

hash_map(
    initializer_list<Type> IList);hash_map(initializer_list<Type> IList,
    const key_compare& Comp);

hash_map(
    initializer_list<Type> IList,
    const key_compare& Comp,
    const allocator_type& Al);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al

Параметры

Al
Класс распределителя памяти для использования с этим объектом hash_map. Значение по умолчанию — Allocator.

Comp
Функция сравнения типа const Traits , используемая для упорядочивания элементов в элементе hash_map, для которого используется значение hash_compareпо умолчанию.

Right
Из hash_map которого построенная карта должна быть копией.

First
Положение первого элемента в диапазоне копируемых элементов.

Last
Положение первого элемента после диапазона копируемых элементов.

IList
initializer_list

Замечания

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

Все конструкторы инициализируют их hash_map.

Все конструкторы хранят объект функции типа Traits , который используется для установления порядка между ключами и hash_map которые позже могут быть возвращены путем вызова key_comp.

Первые три конструктора указывают пустой начальный hash_map, а второй — тип функции сравнения (Comp) для установки порядка элементов, а третий явно указывает тип используемого типа распределителя (Al). Ключевое слово explicit подавляет определенные виды автоматического преобразования типов.

Четвертый конструктор указывает копию hash_map Right.

Следующие три конструктора копируют диапазон с [First, Last) hash_map увеличением явности при указании типа функции сравнения класса Traits и распределителя.

Последний конструктор перемещает hash_map Right.

hash_map::insert

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Вставляет элемент или диапазон элементов в hash_map.

pair <iterator, bool> insert(
    const value_type& val);

iterator insert(
    const_iterator _Where,
    const value_type& val);

template <class InputIterator>
void insert(
    InputIterator first,
    InputIterator last);

template <class ValTy>
pair <iterator, bool>
insert(
    ValTy&& val);

template <class ValTy>
iterator insert(
    const_iterator _Where,
    ValTy&& val);

Параметры

val
Значение элемента, которое необходимо вставить hash_map в, если hash_map он уже не содержит этот элемент (или, как правило, элемент, ключ которого эквивалентно упорядочен).

_Where
Подсказка о месте начала поиска правильной точки вставки.

first
Позиция первого элемента для копирования из hash_map.

last
Позиция сразу после последнего элемента для копирования из hash_map.

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

Первая insert функция-член возвращает пару, компонент которой bool возвращает true значение, если вставка была выполнена, и false если hash_map элемент уже содержал элемент, ключ которого имел эквивалентное значение в порядке, и компонент итератора возвращает адрес, в котором был вставлен новый элемент или где элемент уже расположен.

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

Вторая insert функция-член, версия подсказки, возвращает итератор, указывающий на позицию, в которую был вставлен hash_mapновый элемент.

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

Замечания

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

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

Третья функция-член вставляет последовательность значений элементов в соответствующую hash_map каждому элементу, адресуемую итератором в диапазоне *[First, Last)* указанного набора.

Пример

// hash_map_insert.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int>::iterator hm1_pIter, hm2_pIter;

    hash_map<int, int> hm1, hm2;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 10));
    hm1.insert(Int_Pair(2, 20));
    hm1.insert(Int_Pair(3, 30));
    hm1.insert(Int_Pair(4, 40));

    cout << "The original elements (Key => Value) of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << " " << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    pair< hash_map<int,int>::iterator, bool > pr;
    pr = hm1.insert(Int_Pair(1, 10));

    if (pr.second == true)
    {
        cout << "The element 10 was inserted in hm1 successfully."
            << endl;
    }
    else
    {
        cout << "The element 10 already exists in hm1\n"
            << "with a key value of "
            << "((pr.first) -> first) = " << (pr.first)->first
            << "." << endl;
    }

    // The hint version of insert
    hm1.insert(--hm1.end(), Int_Pair(5, 50));

    cout << "After the insertions, the elements of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    hm2.insert(Int_Pair(10, 100));

    // The templatized version inserting a range
    hm2.insert( ++hm1.begin(), --hm1.end() );

    cout << "After the insertions, the elements of hm2 are:";
    for (hm2_pIter = hm2.begin(); hm2_pIter != hm2.end(); hm2_pIter++)
        cout << endl << hm2_pIter -> first << " => "
             << hm2_pIter->second;
    cout << endl;

    // The templatized versions move constructing elements
    hash_map<int, string> hm3, hm4;
    pair<int, string> is1(1, "a"), is2(2, "b");

    hm3.insert(move(is1));
    cout << "After the move insertion, hm3 contains:" << endl
      << hm3.begin()->first
      << " => " << hm3.begin()->second
      << endl;

    hm4.insert(hm4.begin(), move(is2));
    cout << "After the move insertion, hm4 contains:" << endl
      << hm4.begin()->first
      << " => " << hm4.begin()->second
      << endl;
}

The original elements (Key => Value) of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
The element 10 already exists in hm1
with a key value of ((pr.first) -> first) = 1.
After the insertions, the elements of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
5 => 50
After the insertions, the elements of hm2 are:
2 => 20
10 => 100
3 => 30
4 => 40
After the move insertion, hm3 contains:
1 => a
After the move insertion, hm4 contains:
2 => b

hash_map::iterator

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

Замечания

Определяется iterator hash_map элементами, которые являются объектами value_typeтипа , pair<const Key, Type>чей первый член является ключом к элементу и чей второй член является сопоставленным datum, удерживаемым элементом.

Чтобы разыменовать итератор с именем Iter , указывающим на элемент в мультикарте, используйте -> оператор.

Чтобы получить доступ к значению ключа для элемента, используйте Iter->first, что эквивалентно (*Iter).first. Чтобы получить доступ к значению сопоставленной datum для элемента, используйте Iter->secondэквивалент (*Iter).second.

Тип iterator можно использовать для изменения значения элемента.

Пример

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

hash_map::key_comp

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Извлекает копию объекта сравнения, который используется для упорядочивания ключей в контейнере hash_map.

key_compare key_comp() const;

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

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

Замечания

Хранимый объект определяет функцию-член

bool operator( const Key& left, const Key&right );

значение возвращается true , если left предшествует и не равно right в порядке сортировки.

Пример

// hash_map_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >::key_compare
      kc1 = hm1.key_comp( ) ;

   // Operator stored in kc1 tests order & returns bool value
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true,"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }

   hash_map <int, int, hash_compare<int, greater<int> > > hm2;
   hash_map <int, int, hash_compare<int, greater<int> > >
      ::key_compare kc2 = hm2.key_comp( );

   // Operator stored in kc2 tests order & returns bool value
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
}

hash_map::key_compare

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef Traits key_compare;

Замечания

key_compare является синонимом для параметра-шаблона Traits.

Дополнительные сведения см. в Traits hash_map разделе "Класс".

Пример

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

hash_map::key_type

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef Key key_type;

Замечания

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

Дополнительные сведения см. в разделе "Примечания Key" раздела hash_map "Класс ".

Пример

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

hash_map::lower_bound

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Возвращает итератор, указывающий на первый элемент в hash_map с ключом, который больше или равен указанному ключу.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Параметры

key
Значение ключа аргумента, которое необходимо сравнить с ключом сортировки элемента из выполняемого hash_map поиска.

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

const_iterator Или iterator адресирует расположение элемента в hash_map том, что с ключом, равным или больше ключа аргумента, или адресирует расположение, успешное выполнение последнего элемента в hash_map случае, если совпадение не найдено для ключа.

Если возвращаемое значение lower_bound назначено объекту const_iterator, hash_map объект нельзя изменить. Если возвращаемое значение lower_bound назначено объекту iterator, hash_map объект можно изменить.

Замечания

Пример

// hash_map_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.lower_bound( 2 );
   cout << "The first element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1. lower_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // An element at a specific location in the hash_map can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1. lower_bound ( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

hash_map::mapped_type

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Тип, который представляет тип данных, хранящийся в контейнере hash_map.

typedef Type mapped_type;

Замечания

Тип mapped_type является синонимом для параметра-шаблона Type.

Дополнительные сведения см. в Type hash_map разделе "Класс".

Пример

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

hash_map::max_size

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Возвращает максимальную длину hash_map.

size_type max_size() const;

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

Максимальная возможная длина hash_map.

Замечания

Пример

// hash_map_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: size_type i;

   i = hm1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_map is " << i << "."
        << endl << "(Magnitude is machine specific.)";
}

hash_map::operator[]

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Вставляет элемент в hash_map с заданным значением ключа.

Type& operator[](const Key& key);

Type& operator[](Key&& key);

Параметры

key
Ключевое значение элемента для вставки.

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

Ссылка на значение данных вставленного элемента.

Замечания

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

operator[] может использоваться для вставки элементов в hash_map m с помощью

m[ key] = DataValue;

где DataValue — значение mapped_type элемента со значением ключа key.

При использовании operator[] для вставки элементов возвращаемая ссылка не указывает, изменяет ли вставка уже существующий элемент или создает новый. Функции-члены find и insert могут использоваться для определения того, присутствует ли элемент с указанным ключом перед вставкой.

Пример

// hash_map_op_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: iterator pIter;

   // Insert a data value of 10 with a key of 1
   // into a hash_map using the operator[] member function
   hm1[ 1 ] = 10;

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( hash_map <int, int> :: value_type ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // If the key already exists, operator[]
   // changes the value of the datum in the element
   hm1[ 2 ] = 40;

   // operator[] will also insert the value of the data
   // type's default constructor if the value is unspecified
   hm1[5];

   cout  << "The keys of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // operator[] will also insert by moving a key
   hash_map <string, int> hm2;
   string str("a");
   hm2[move(str)] = 1;
   cout << "The moved key is " << hm2.begin()->first
      << ", with value " << hm2.begin()->second << endl;
}

hash_map::operator=

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Заменяет элементы hash_map копией другого hash_map.

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

Параметры

right
Класс right копируется в объект hash_map.

Замечания

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

Пример

// hash_map_operator_as.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

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

   v1.insert(pair<int, int>(1, 10));

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

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

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

hash_map::pointer

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::pointer pointer;

Замечания

Тип pointer можно использовать для изменения значения элемента.

В большинстве случаев iterator необходимо использовать для доступа к элементам в объекте hash_map .

hash_map::rbegin

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

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

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

Замечания

rbegin используется с обратным hash_map так же, как begin используется с hash_map.

Если возвращаемое значение rbegin назначено объекту const_reverse_iterator, hash_map объект не может быть изменен. Если возвращаемое значение rbegin назначено объекту reverse_iterator, hash_map его можно изменить.

rbegin можно использовать для перебора hash_map в обратном порядке.

Пример

// hash_map_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( ); hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = hm1.rbegin( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}

The first element of the reversed hash_map hm1 is 3.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the first element in the reversed hash_map is 2.

hash_map::reference

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;

Замечания

Пример

// hash_map_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error as the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of first element in the hash_map is "
        << Ref2 << "." << endl;

   // The non-const_reference can be used to modify the
   // data value of the first element
   Ref2 = Ref2 + 5;
   cout << "The modified data value of first element is "
        << Ref2 << "." << endl;
}

The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The modified data value of first element is 15.

hash_map::rend

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

const_reverse_iterator rend() const;

reverse_iterator rend();

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

Обратный двунаправленный итератор, который обращается к расположению, успешному последнему элементу в обратном hash_map направлении (расположение, которое предшествовало первому элементу в непровернутом hash_map).

Замечания

rend используется с обратным hash_map так же, как end используется с hash_map.

Если возвращаемое значение rend назначено объекту const_reverse_iterator, hash_map объект не может быть изменен. Если возвращаемое значение rend назначено объекту reverse_iterator, hash_map его можно изменить.

rend используется, чтобы проверить, достиг ли итератор конца hash_map.

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

Пример

// hash_map_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( );
   hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( );
      hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = --hm1.rend( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}

The last element of the reversed hash_map hm1 is 1.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the last element in the reversed hash_map is 2.

hash_map::reverse_iterator

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

Замечания

Тип reverse_iterator не может изменить значение элемента и используется для итерации с помощью обратного hash_map элемента.

Определяется reverse_iterator hash_map элементами , которые являются объектами value_type, то есть типом pair<const Key, Type>, первый член которого является ключом к элементу и второй член которого является сопоставленным datum, удерживаемым элементом.

Чтобы разыменовать reverse_iterator rIter элемент в элементе hash_map, используйте -> оператор.

Чтобы получить доступ к значению ключа для элемента, используйте rIter->first, что эквивалентно (*rIter).first. Чтобы получить доступ к значению сопоставленной datum для элемента, используйте rIter->secondэквивалент (*rIter).first.

Пример

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

hash_map::size

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Возвращает количество элементов в контейнере hash_map.

size_type size() const;

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

Текущая длина hash_map.

Замечания

Пример

В следующем примере показано использование hash_map::size функции-члена.

// hash_map_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    i = hm1.size();
    cout << "The hash_map length is " << i << "." << endl;

    hm1.insert(Int_Pair(2, 4));
    i = hm1.size();
    cout << "The hash_map length is now " << i << "." << endl;
}

The hash_map length is 1.
The hash_map length is now 2.

hash_map::size_type

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

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

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;

Замечания

Пример

Пример size объявления и использования size_type

hash_map::swap

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Выполняет обмен элементами между двумя объектами hash_map.

void swap(hash_map& right);

Параметры

right
Аргумент hash_map , предоставляющий элементы для переключения с целевым объектом hash_map.

Замечания

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

Пример

// hash_map_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2, hm3;
   hash_map <int, int>::iterator hm1_Iter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );
   hm2.insert ( Int_Pair ( 10, 100 ) );
   hm2.insert ( Int_Pair ( 20, 200 ) );
   hm3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   // hm2 is said to be the argument hash_map;
   // hm1 is said to be the target hash_map
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hm1, hm3 );

   cout << "After swapping with hm3, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

The original hash_map hm1 is: 10 20 30.
After swapping with hm2, hash_map hm1 is: 100 200.
After swapping with hm3, hash_map hm1 is: 300.

hash_map::upper_bound

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Возвращает итератор первому элементу в hash_map том, что с ключом, имеющим значение, больше указанного ключа.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Параметры

key
Значение ключа аргумента, которое необходимо сравнить со значением ключа сортировки элемента из выполняемого hash_map поиска.

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

Объект iterator или const_iterator адресирует расположение элемента в hash_map том, что с ключом больше ключа аргумента или адресует расположение, успешное выполнение последнего элемента в hash_map случае, если совпадение не найдено для ключа.

Если возвращаемое значение назначено объекту const_iterator, hash_map объект не может быть изменен. Если возвращаемое значение назначено iteratorобъекту, hash_map объект можно изменить.

Замечания

Пример

// hash_map_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_map hm1 with a key "
        << "greater than 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end is returned
   hm1_RcIter = hm1. upper_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key greater than 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key > 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.begin( );
   hm1_RcIter = hm1. upper_bound ( hm1_AcIter -> first );
   cout << "The 1st element of hm1 with a key greater than that\n"
        << "of the initial element of hm1 is: "
        << hm1_RcIter -> second << "." << endl;
}

The first element of hash_map hm1 with a key greater than 2 is: 30.
The hash_map hm1 doesn't have an element with a key greater than 4.
The 1st element of hm1 with a key greater than that
of the initial element of hm1 is: 20.

hash_map::value_comp

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Возвращает объект функции, определяющий порядок элементов в объекте hash_map , сравнивая их значения ключей.

value_compare value_comp() const;

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

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

Замечания

Если два элемента e1 (, d1) и e2 (k1k2,d2) являются объектами типа, где k1 и k2 являются их ключами типа key_type value_typeи d2 d1 являются их данными типаmapped_type, то m.value_comp()(e1, e2) эквивалентенm.key_comp()(k1, k2).hash_map m Хранимый объект определяет функцию-член

bool operator(value_type& left, value_type& right);

возвращает true значение, если значение left ключа предшествует и не равно значению ключа right в порядке сортировки.

Пример

// hash_map_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >
   ::value_compare vc1 = hm1.value_comp( );
   pair< hash_map<int,int>::iterator, bool > pr1, pr2;

   pr1= hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );
   pr2= hm1.insert ( hash_map <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *pr1.first, *pr2.first ) == true )
   {
      cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
           << endl;
   }
   else
   {
      cout << "The element ( 1,10 ) does not precede the element ( 2,5 )."
           << endl;
   }

   if( vc1 ( *pr2.first, *pr1.first ) == true )
   {
      cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
           << endl;
   }
   else
   {
      cout << "The element ( 2,5 ) does not precede the element ( 1,10 )."
           << endl;
   }
}

hash_map::value_type

Примечание.

Этот элемент API устарел. Альтернативой является unordered_map класс.

Тип, представляющий тип объекта, хранящегося в объекте hash_map.

typedef pair<const Key, Type> value_type;

Замечания

value_type объявляется pair<const key_type, mapped_type> pair<key_type, mapped_type> как не так, так как ключи ассоциативного контейнера не могут быть изменены с помощью неконстантного итератора или ссылки.

Пример

// hash_map_value_type.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: key_type key1;
   hash_map <int, int> :: mapped_type mapped1;
   hash_map <int, int> :: value_type value1;
   hash_map <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1[ 3 ] = 30;

   // Initializing key1 and mapped1
   key1 = ( hm1.begin( ) -> first );
   mapped1 = ( hm1.begin( ) -> second );

   cout << "The key of first element in the hash_map is "
        << key1 << "." << endl;

   cout << "The data value of first element in the hash_map is "
        << mapped1 << "." << endl;

   // The following line would cause an error because
   // the value_type is not assignable
   // value1 = cInt2Int ( 4, 40 );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;
}

The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.

См. также

Потокобезопасность в стандартной библиотеке C++
Справочник по стандартной библиотеке C++