Класс hash_multimap

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

Синтаксис

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

Параметры

Ключ
Тип данных ключа, который необходимо сохранить в hash_multimap.

Тип
Тип данных элемента, который необходимо сохранить в hash_multimap.

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

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

Замечания

hash_multimap:

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

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

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

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

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

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

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

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

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

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

В целом, упорядочиваемые элементы должны лишь подлежать сравнению "меньше чем" для установления такого порядка, чтобы, имея любые два элемента, можно было определить, что они равны (ни один не меньше другого) или что один меньше другого. Это приводит к упорядочению неравнозначных элементов. С более технической точки зрения, функция сравнения является бинарным предикатом, который вызывает строгого слабое упорядочение в стандартном математически смысле. Бинарный предикат f(x, y) является объектом функции, обладающим двумя объектами аргументов x и y, а также возвращаемым значением true или false. Порядок, заданный для hash_multimap, является строгим слабым порядком, если бинарный предикат нерефлексивный, антисимметричный и транзитивный и если эквивалентность является транзитивной, где два объекта — x и y — определяются как эквивалентные, а f(x, y) и f(y, x) имеет значение false. Если более строгое условие равенства между ключами заменяет условие эквивалентности, порядок становится общим (т.е. все элементы упорядочиваются относительно друг друга), и сопоставленные ключи будут неотличимы друг от друга.

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

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

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

Конструктор	Description
hash_multimap	Создает список определенного размера или с элементами, обладающими указанным значением или указанным allocator, либо в качестве копии другого hash_multimap.

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

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

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

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

Операторы

Operator	Description
hash_multimap::operator=	Заменяет элементы hash_multimap копией другого hash_multimap.

Требования

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

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

hash_multimap::allocator_type

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

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

Дополнительные сведения о Allocator см. в подразделе "Примечания" документации к разделу Класс hash_multimap.

Пример

См. пример для get_allocator в качестве примера и использования allocator_type.

hash_multimap::begin

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

const_iterator begin() const;

iterator begin();

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

Двунаправленный итератор, адресующий расположение первого элемента в hash_multimap или расположение после пустого hash_multimap.

Замечания

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

Пример

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

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

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <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_multimap::cbegin

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

const_iterator cbegin() const;

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

Постоянный двунаправленный итератор, адресующий первый элемент в hash_multimap или расположение после пустого hash_multimap.

Пример

// hash_multimap_cbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   hash_multimap <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_multimap::cend

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

const_iterator cend() const;

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

Двунаправленный итератор const bidirectional, адресующий место, следующее за последним элементом в hash_multimap. Если hash_multimap является пустым, то hash_multimap::cend == hash_multimap::begin.

Замечания

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

Значение, возвращаемое cend, не должно быть подвергнуто удалению ссылки.

Пример

// hash_multimap_cend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   hash_multimap <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_multimap::clear

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

Стирает все элементы в объекте hash_multimap.

void clear();

Замечания

Пример

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

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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_multimap is initially "
         << i  << "." << endl;

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

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

hash_multimap::const_iterator

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

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

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

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

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

Пример

См. пример для begin в качестве примера использования const_iterator.

hash_multimap::const_pointer

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

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

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

hash_multimap::const_reference

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

Пример

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<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 first element in the hash_multimap 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 1st element in the hash_multimap is "
        << Ref2 << "." << endl;
}

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

hash_multimap::const_reverse_iterator

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

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

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

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

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

Пример

См. пример для rend в качестве примера объявления и использования const_reverse_iterator.

hash_multimap::count

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

size_type count(const Key& key) const;

Параметры

key
Ключ для сравнения с ключами элементов объекта hash_multimap.

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

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

Замечания

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

[lower_bound ( key ), upper_bound ( ) key

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

Пример

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

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

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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));

    // Elements do not need to have unique keys in hash_multimap,
    // so duplicates are allowed and counted
    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: 2.
The number of elements in hm1 with a sort key of 2 is: 2.
The number of elements in hm1 with a sort key of 3 is: 0.

hash_multimap::crbegin

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

const_reverse_iterator crbegin() const;

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

Константный обратный двунаправленный итератор, адресующий первый элемент в обратном hash_multimap (или адресующий элемент, ранее бывший последним элементом в hash_multimap до изменения его порядка на обратный).

Замечания

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

Если возвращаемое значение crbegin, то объект hash_multimap невозможно изменить.

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

Пример

// hash_multimap_crbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   hash_multimap <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_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_multimap hm1 is 3.

hash_multimap::crend

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

const_reverse_iterator crend() const;

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

Константный обратный двунаправленный итератор, адресующий место после последнего элемента в обратном hash_multimap (расположение перед первым элементом в hash_multimap до изменения его порядка на обратный).

Замечания

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

Если возвращаемое значение crend, то объект hash_multimap невозможно изменить.

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

Значение, возвращаемое crend, не должно быть подвергнуто удалению ссылки.

Пример

// hash_multimap_crend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

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

   hash_multimap <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_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_multimap hm1 is 3.

hash_multimap::d ifference_type

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

difference_type — тип, возвращаемый при вычитании или приращении через итераторы контейнера. difference_type обычно используется для представления количества элементов в диапазоне [ first, last) между итераторами first и last, включая элемент, на который указывает first, и диапазон элементов до элемента, на который указывает last, но не включая его.

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

Пример

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<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 will insert, because map keys
    // do not need to be unique
    hm1.insert(Int_Pair(2, 30));

    hash_multimap<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_multimap
    hash_multimap<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_multimap 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_multimap hm1 is: 4.
The keys of the mapped elements are: 1 2 2 3.
The values of the mapped elements are: 10 20 30 20.

hash_multimap::emplace

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Параметры

Val
Значение, используемое для перемещения, формирует элемент для вставки в hash_multimap.

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

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

Замечания

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

Пример

// hash_multimap_emplace.cpp
// compile with: /EHsc
#include<hash_multimap>
#include<iostream>
#include <string>

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

    hm1.emplace(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_multimap::emplace_hint

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Параметры

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

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

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

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

Замечания

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

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

Пример

// hash_multimap_emplace_hint.cpp
// compile with: /EHsc
#include<hash_multimap>
#include<iostream>
#include <string>

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

    hm1.emplace(hm1.begin(), 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_multimap::empty

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

Проверяет, что hash_multimap пуст.

bool empty() const;

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

true Значение ,если hash_multimap пуст; false Значение , если hash_multimap не является непустимой.

Замечания

Пример

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

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

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

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

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

The hash_multimap hm1 is not empty.
The hash_multimap hm2 is empty.

hash_multimap::end

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

Возвращает итератор, адресующий место, следующее за последним элементом в hash_multimap.

const_iterator end() const;

iterator end();

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

Двунаправленный итератор, адресующий место, которое следует за последним элементом в hash_multimap. Если hash_multimap пуст, то hash_multimap::end == hash_multimap::begin.

Замечания

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

Значение, возвращаемое end, не должно быть подвергнуто удалению ссылки.

Пример

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

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

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <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_multimap::equal_range

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

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

Параметры

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

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

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

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

Замечания

Пример

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

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_multimap <int, int> IntMMap;
   IntMMap hm1;
   hash_multimap <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 <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

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

   cout << "The upper bound of the element with a key of 2\n"
        << "in the hash_multimap 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_multimap hm1 doesn't have an element "
           << "with a key less than 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2
in the hash_multimap hm1 is: 20.
The upper bound of the element with a key of 2
in the hash_multimap 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_multimap hm1 doesn't have an element with a key less than 4.

hash_multimap::erase

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Параметры

_Где
Положение элемента, удаляемого из объекта hash_multimap.

first
Положение первого элемента, удаляемого из объекта hash_multimap.

last
Положение сразу после последнего элемента, удаляемого из объекта hash_multimap.

key
Ключ элементов, удаляемых из объекта hash_multimap.

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

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

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

Замечания

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

Пример

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

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1, hm2, hm3;
    hash_multimap<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_multimap<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_multimap 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_multimap 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
    hm3.insert(Int_Pair (2, 5));
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_multimap 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 of the"
         << endl;
    cout  << "2nd element is deleted, "
          << "the hash_multimap hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

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

hash_multimap::find

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Параметры

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

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

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

Замечания

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

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

Пример

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

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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, 20));
    hm1.insert(Int_Pair(3, 30));

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

    hm1_RcIter = hm1.find(3);
    cout << "The first element of hash_multimap hm1 with a key of 3 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_multimap hm1 doesn't have an element "
             << "with a key of 4." << endl;
    else
        cout << "The element of hash_multimap hm1 with a key of 4 is: "
             << hm1_RcIter -> second << "." << endl;

    // The element at a specific location in the hash_multimap 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 first element of hm1 with a key matching"
         << endl << "that of the last element is: "
         << hm1_RcIter -> second << "." << endl;

    // Note that the first element with a key equal to
    // the key of the last element is not the last element
    if (hm1_RcIter == --hm1.end())
        cout << "This is the last element of hash_multimap hm1."
             << endl;
    else
        cout << "This is not the last element of hash_multimap hm1."
             << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::get_allocator

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

Allocator get_allocator() const;

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

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

Замечания

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

Пример

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

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

   // The following lines declare objects
   // that use the default allocator.
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> hm2;
   hash_multimap <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_multimap hm4
   // with the allocator of hash_multimap hm1.
   hash_multimap <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

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

hash_multimap::hash_multimap

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

Создает hash_multimap, который пуст или является копией части или целого другого hash_multimap.

hash_multimap();

explicit hash_multimap(
    const Compare& Comp);

hash_multimap(
    const Compare& Comp,
    const Allocator& Al);

hash_multimap(
    const hash_multimap& Right);

hash_multimap(
    hash_multimap&& Right);

hash_multimap(
    initializer_list<Type> IList);

hash_multimap(
    initializer_list<Type> IList,
    const Compare& Comp);

hash_multimap(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

template <class InputIterator>
hash_multimap(
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

template <class InputIterator>
hash_multimap(
    InputIterator First,
    InputIterator Last,
    const Compare& Comp,
    const Allocator& Al);

Параметры

Аль
Класс распределителя хранилища для данного объекта hash_multimap, значение по умолчанию Allocator.

Комп
Функция сравнения типа const Traits для использования при упорядочивании элементов в сопоставлении. Значение по умолчанию — Traits.

Right
Сопоставление, копией которого будет создаваемое сопоставление.

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

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

IList
Копируемый initializer_list.

Замечания

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

Все конструкторы выполняют инициализацию своих hash_multimap.

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

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

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

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

Восьмой конструктор перемещает hash_multimap Right.

Последние три конструктора используют initializer_list.

hash_multimap::insert

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

iterator insert(
    const value_type& Val);

iterator insert(
    const_iterator Where,
    const value_type& Val);void insert(
    initializer_list<value_type> IList);

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

template <class ValTy>
iterator insert(
    ValTy&& Val);

template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

Параметры

Валь
Значение элемента, вставляемого в hash_multimap, если он уже не содержит этот элемент, или в более общем смысле, если он уже не содержит элемент, ключ которого эквивалентно задан.

Where
Подсказка, где начинать поиск правильной точки вставки.

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

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

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

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

Третья функция-член использует initializer_list для вставляемых элементов.

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

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

Замечания

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

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

hash_multimap::iterator

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

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

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

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

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

Пример

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

hash_multimap::key_comp

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

key_compare key_comp() const;

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

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

Замечания

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

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

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

Пример

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

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

   hash_multimap <int, int, hash_compare<int, less<int>>> hm1;
   hash_multimap <int, int, hash_compare<int, less<int>>
      >::key_compare kc1 = hm1.key_comp( ) ;
   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.\n"
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false,\n"
           << "where kc1 is the function object of hm1.\n"
           << endl;
   }

   hash_multimap <int, int, hash_compare<int, greater<int>>> hm2;
   hash_multimap <int, int, hash_compare<int, greater<int>>
      >::key_compare kc2 = hm2.key_comp( );
   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."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,\n"
           << "where kc2 is the function object of hm2."
           << endl;
   }
}

hash_multimap::key_compare

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

typedef Traits key_compare;

Замечания

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

Дополнительные сведения о признаках см. в разделе о классе hash_multimap.

Пример

См. пример для key_comp в качестве примера объявления и использования key_compare.

hash_multimap::key_type

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

typedef Key key_type;

Замечания

key_typeявляется синонимом ключа параметра шаблона.

Дополнительные сведения о ключе см. в разделе "Примечания" раздела класса hash_multimap.

Пример

См. пример для value_type в качестве примера объявления и использования key_compare.

hash_multimap::lower_bound

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Параметры

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

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

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

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

Замечания

Пример

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <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, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

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

   hm1_RcIter = hm1.lower_bound( 3 );
   cout << "The first element of hash_multimap hm1 with a key of 3 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_multimap hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_multimap 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 first element of hm1 with a key matching"
        << endl << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;

   // Note that the first element with a key equal to
   // the key of the last element is not the last element
   if ( hm1_RcIter == --hm1.end( ) )
      cout << "This is the last element of hash_multimap hm1."
           << endl;
   else
      cout << "This is not the last element of hash_multimap hm1."
           << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::mapped_type

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

Тип, представляющий тип данных, хранящийся в hash_multimap.

typedef Type mapped_type;

Замечания

mapped_type — синоним параметра-шаблона Type.

Дополнительные сведения о типе см. в разделе о классе hash_multimap.

Пример

См. пример для value_type в качестве примера объявления и использования key_type.

hash_multimap::max_size

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

size_type max_size() const;

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

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

Замечания

Пример

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

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

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

hash_multimap::operator=

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

hash_multimap& operator=(const hash_multimap& right);

hash_multimap& operator=(hash_multimap&& right);

Параметры

right
Hash_multimap, который копируется в hash_multimap.

Замечания

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

Пример

// hash_multimap_operator_as.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<int, int> v1, v2, v3;
   hash_multimap<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_multimap::p ointer

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

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

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

hash_multimap::rbegin

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

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

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

Замечания

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

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

rbegin можно использовать для прохода по hash_multimap в обратную стороны.

Пример

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

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

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <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_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multimap in a forward order
   cout << "The hash_multimap 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_multimap in a reverse order
   cout << "The reversed hash_multimap is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

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

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

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

hash_multimap::reference

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

Пример

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <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_multimap 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_multimap 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_multimap is 1.
The data value of first element in the hash_multimap is 10.
The modified data value of first element is 15.

hash_multimap::rend

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

const_reverse_iterator rend() const;

reverse_iterator rend();

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

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

Замечания

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

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

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

Значение, возвращаемое rend, не должно быть подвергнуто удалению ссылки.

Пример

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

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

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <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_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multimap in a forward order
   cout << "The hash_multimap 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_multimap in a reverse order
   cout << "The reversed hash_multimap is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_multimap element can be erased by dereferencing 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_multimap is "
        << hm1_rIter -> first << "." << endl;
}

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

hash_multimap::reverse_iterator

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

Тип reverse_iterator используется для последовательного перебора hash_multimap в обратную сторону.

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

Пример

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

hash_multimap::size

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

size_type size() const;

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

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

Замечания

Пример

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

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

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

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

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

The hash_multimap length is 1.
The hash_multimap length is now 2.

hash_multimap::size_type

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

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

Замечания

Пример

См. пример для size в качестве примера объявления и использования size_type

hash_multimap::swap

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

Меняет местами элементы двух hash_multimap.

void swap(hash_multimap& right);

Параметры

right
Hash_multimap, предоставляющий элементы для обмена местами, или hash_multimap, элементы которого должны обменяться с элементами hash_multimap.

Замечания

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

Пример

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1, hm2, hm3;
   hash_multimap <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_multimap 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
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_multimap 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_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

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

hash_multimap::upper_bound

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Параметры

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

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

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

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

Замечания

Пример

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

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <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.insert ( Int_Pair ( 3, 40 ) );

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

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_multimap hm1\n"
        << "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.lower_bound( 4 );

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

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

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

hash_multimap::value_comp

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

value_compare value_comp() const;

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

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

Замечания

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

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

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

Пример

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

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

   hash_multimap <int, int, hash_compare<int, less<int>>> hm1;
   hash_multimap <int, int, hash_compare<int, less<int>>
      >::value_compare vc1 = hm1.value_comp( );
   hash_multimap <int,int>::iterator Iter1, Iter2;

   Iter1= hm1.insert ( hash_multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= hm1.insert ( hash_multimap <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *Iter1, *Iter2 ) == 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( *Iter2, *Iter1 ) == 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_multimap::value_type

Примечание.

Этот элемент API устарел. Вместо него следует использовать unordered_multimap Class.

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

typedef pair<const Key, Type> value_type;

Замечания

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

Пример

// hash_multimap_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_multimap <int, int> hm1;
   hash_multimap <int, int> :: key_type key1;
   hash_multimap <int, int> :: mapped_type mapped1;
   hash_multimap <int, int> :: value_type value1;
   hash_multimap <int, int> :: iterator pIter;

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

   // Compare another way to insert objects into a hash_multimap
   hm1.insert ( cInt2Int ( 2, 20 ) );

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

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

   cout << "The data value of first element in the hash_multimap 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_multimap is 1.
The data value of first element in the hash_multimap is 10.
The keys of the mapped elements are: 1 2.
The values of the mapped elements are: 10 20.

См. также

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