Класс multimap

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

Синтаксис

template <class Key,
    class Type,
    class Traits=less <Key>,
    class Allocator=allocator <pair  <const Key, Type>>>
class multimap;

Параметры

Key
Тип данных ключа для сохранения в контейнере multimap.

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

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

В C++ 14 вы можете включить разнородный поиск, указав предикат std::less<> или std::greater<>, не имеющий параметров типа. Дополнительные сведения см. в статье Разнородный поиск в ассоциативных контейнерах

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

Замечания

Класс multimap в стандартной библиотеке С++ — это:

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

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

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

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

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

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

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

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

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

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

В C++ 14 вы можете включить разнородный поиск, указав предикат std::less<> или std::greater<>, не имеющий параметров типа. Дополнительные сведения см . в разделе "Разнородный поиск" в ассоциативных контейнерах .

Участники

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

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

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

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

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

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

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

Требования

Заголовок.<map>

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

Пары ( ключ, значение) хранятся в multimap виде объектов типа pair. Для класса пары требуется заголовок <utility>, который автоматически включается <map>.

multimap::allocator_type

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

typedef Allocator allocator_type;

Пример

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

multimap::begin

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

const_iterator begin() const;

iterator begin();

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

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

Пример

// multimap_begin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: const_iterator m1_cIter;
   typedef pair <int, int> Int_Pair;

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

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

   m1_Iter = m1.begin ( );
   m1.erase ( m1_Iter );

   // The following 2 lines would err as the iterator is const
   // m1_cIter = m1.begin ( );
   // m1.erase ( m1_cIter );

   m1_cIter = m1.begin( );
   cout << "First element of m1 is now " << m1_cIter -> first << endl;
}

The first element of m1 is 0
First element of m1 is now 1

multimap::cbegin

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

const_iterator cbegin() const;

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

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

Замечания

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

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

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

// i2 is Container<T>::const_iterator

multimap::cend

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

const_iterator cend() const;

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

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

Замечания

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

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

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

// i2 is Container<T>::const_iterator

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

multimap::clear

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

void clear();

Пример

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

// multimap_clear.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap<int, int> m1;
   multimap<int, int>::size_type i;
   typedef pair<int, int> Int_Pair;

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

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

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

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

multimap::const_iterator

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

typedef implementation-defined const_iterator;

Замечания

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

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

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

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

Пример

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

multimap::const_pointer

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

typedef typename allocator_type::const_pointer const_pointer;

Замечания

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

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

multimap::const_reference

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

typedef typename allocator_type::const_reference const_reference;

Пример

// multimap_const_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

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

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

multimap::const_reverse_iterator

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

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Замечания

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

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

Для разыменования const_reverse_iteratorcrIter, указывающего на элемент в мультиотображении, используйте оператор ->.

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

Пример

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

multimap::contains

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

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

Параметры

K
Тип ключа.

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

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

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

Замечания

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

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

Пример

// Requires /std:c++20 or /std:c++latest
#include <map>
#include <string>
#include <iostream>
#include <functional>

int main()
{
    std::multimap<int, bool> m = {{0, false}, {1, true}};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << m.contains(1) << '\n';
    std::cout << m.contains(2) << '\n';

    // call template function
    std::multimap<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

multimap::count

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

size_type count(const Key& key) const;

Параметры

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

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

Число элементов, ключи сортировки которых совпадают с ключом параметра. 0, если мультиотображение не содержит ни одного элемента с совпадающим ключом.

Замечания

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

lower_bound(key), upper_bound(key)

имеющий значение ключа key.

Пример

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

// multimap_count.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
    using namespace std;
    multimap<int, int> m1;
    multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

    // Elements don't need to have unique keys in multimap,
    // so duplicates are allowed and counted
    i = m1.count(1);
    cout << "The number of elements in m1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

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

multimap::crbegin

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

const_reverse_iterator crbegin() const;

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

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

Замечания

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

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

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

Пример

// multimap_crbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_crIter = m1.crbegin( );
   cout << "The first element of the reversed multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed multimap m1 is 3.

multimap::crend

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

const_reverse_iterator crend() const;

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

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

Замечания

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

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

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

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

Пример

// multimap_crend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_crIter = m1.crend( );
   m1_crIter--;
   cout << "The last element of the reversed multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed multimap m1 is 1.

multimap::difference_type

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

typedef typename allocator_type::difference_type difference_type;

Замечания

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

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

Пример

// multimap_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <map>
#include <algorithm>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

   // The following will insert as multimap keys are not unique
   m1.insert ( Int_Pair ( 2, 30 ) );

   multimap <int, int>::iterator m1_Iter, m1_bIter, m1_eIter;
   m1_bIter = m1.begin( );
   m1_eIter = m1.end( );

   // Count the number of elements in a multimap
   multimap <int, int>::difference_type  df_count = 0;
   m1_Iter = m1.begin( );
   while ( m1_Iter != m1_eIter )
   {
      df_count++;
      m1_Iter++;
   }

   cout << "The number of elements in the multimap m1 is: "
        << df_count << "." << endl;
}

The number of elements in the multimap m1 is: 4.

multimap::emplace

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

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

Параметры

args
Аргументы, пересылаемые для создания элемента, вставляемого в объект multimap.

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

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

Замечания

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

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

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

Пример

// multimap_emplace.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: " << endl;

    for (const auto& p : m) {
        cout << "(" << p.first <<  "," << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    multimap<string, string> m1;

    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

    cout << "multimap modified, now contains ";
    print(m1);
    cout << endl;

    m1.emplace("Bob", "Engineering");

    cout << "multimap modified, now contains ";
    print(m1);
    cout << endl;
}

multimap::emplace_hint

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

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

Параметры

args
Аргументы, пересылаемые для создания элемента, вставляемого в объект multimap.

where
Место начала поиска правильной точки вставки. (Если эта точка находится непосредственно перед where, вставка может быть выполнена в постоянном времени с поправкой на амортизацию, а не в логарифмическом времени.)

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

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

Замечания

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

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

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

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

multimap::empty

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

bool empty() const;

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

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

Пример

// multimap_empty.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2;

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

   if ( m1.empty( ) )
      cout << "The multimap m1 is empty." << endl;
   else
      cout << "The multimap m1 is not empty." << endl;

   if ( m2.empty( ) )
      cout << "The multimap m2 is empty." << endl;
   else
      cout << "The multimap m2 is not empty." << endl;
}

The multimap m1 is not empty.
The multimap m2 is empty.

multimap::end

Возврат итератора после конца.

const_iterator end() const;

iterator end();

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

Итератор после конца. Если multimap является пустым, то multimap::end() == multimap::begin().

Замечания

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

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

Пример кода см. в разделе multimap::find.

multimap::equal_range

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

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

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

Параметры

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

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

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

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

Пример

// multimap_equal_range.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   typedef multimap <int, int, less<int> > IntMMap;
   IntMMap m1;
   multimap <int, int> :: const_iterator m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   pair <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = m1.equal_range( 2 );

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

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

   // Compare the upper_bound called directly
   m1_RcIter = m1.upper_bound( 2 );

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

   p2 = m1.equal_range( 4 );

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

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

multimap::erase

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

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Параметры

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

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

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

Key
Ключевое значение элементов для удаления.

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

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

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

Замечания

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

multimap::find

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Параметры

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

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

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

Замечания

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

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

Пример

// compile with: /EHsc /W4 /MTd
#include <map>
#include <iostream>
#include <vector>
#include <string>
#include <utility>  // make_pair()

using namespace std;

template <typename A, typename B> void print_elem(const pair<A, B>& p) {
    cout << "(" << p.first << ", " << p.second << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    multimap<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting multimap m1 is (key, value):" << endl;
    print_collection(m1);

    vector<pair<int, string>> v;
    v.push_back(make_pair(43, "Tc"));
    v.push_back(make_pair(41, "Nb"));
    v.push_back(make_pair(46, "Pd"));
    v.push_back(make_pair(42, "Mo"));
    v.push_back(make_pair(44, "Ru"));
    v.push_back(make_pair(44, "Ru")); // attempt a duplicate

    cout << "Inserting the following vector data into m1:" << endl;
    print_collection(v);

    m1.insert(v.begin(), v.end());

    cout << "The modified multimap m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

multimap::get_allocator

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

allocator_type get_allocator() const;

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

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

Замечания

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

Пример

// multimap_get_allocator.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int>::allocator_type m1_Alloc;
   multimap <int, int>::allocator_type m2_Alloc;
   multimap <int, double>::allocator_type m3_Alloc;
   multimap <int, int>::allocator_type m4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   multimap <int, int> m1;
   multimap <int, int, allocator<int> > m2;
   multimap <int, double, allocator<double> > m3;

   m1_Alloc = m1.get_allocator( );
   m2_Alloc = m2.get_allocator( );
   m3_Alloc = m3.get_allocator( );

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

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

   // The following line creates a multimap m4
   // with the allocator of multimap m1.
   map <int, int> m4( less<int>( ), m1_Alloc );

   m4_Alloc = m4.get_allocator( );

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

multimap::insert

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

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

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

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Параметры

Val
Значение элемента, который необходимо вставить в multimap.

Where
Место начала поиска правильной точки вставки. (Если эта точка находится непосредственно перед Where, вставка может быть выполнена в постоянном времени с поправкой на амортизацию, а не в логарифмическом времени.)

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

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

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

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

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

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

Функции-члены с одним элементом (1) и (2) возвращают итератор в положение, в котором вставляется multimapновый элемент.

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

Замечания

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

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

Контейнер value_type представляет собой типдифакт, который принадлежит контейнеру, а для сопоставления multimap<K, V>::value_type — pair<const K, V>. Значение элемента — это упорядоченная пара, в которой первый компонент эквивалентен значению ключа, а второй компонент — значению данных элемента.

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

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

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

Пример

// multimap_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>
#include <vector>
#include <utility>  // make_pair()

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    multimap<int, int> m1;
    // call insert(const value_type&) version
    m1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    m1.insert(make_pair(2, 20));

    cout << "The original key and mapped values of m1 are:" << endl;
    print(m1);

    // intentionally attempt a duplicate, single element
    m1.insert(make_pair(1, 111));

    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);

    // single element, with hint
    m1.insert(m1.end(), make_pair(3, 30));
    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);
    cout << endl;

    // The templatized version inserting a jumbled range
    multimap<int, int> m2;
    vector<pair<int, int>> v;
    v.push_back(make_pair(43, 294));
    v.push_back(make_pair(41, 262));
    v.push_back(make_pair(45, 330));
    v.push_back(make_pair(42, 277));
    v.push_back(make_pair(44, 311));

    cout << "Inserting the following vector data into m2:" << endl;
    print(v);

    m2.insert(v.begin(), v.end());

    cout << "The modified key and mapped values of m2 are:" << endl;
    print(m2);
    cout << endl;

    // The templatized versions move-constructing elements
    multimap<int, string>  m3;
    pair<int, string> ip1(475, "blue"), ip2(510, "green");

    // single element
    m3.insert(move(ip1));
    cout << "After the first move insertion, m3 contains:" << endl;
    print(m3);

    // single element with hint
    m3.insert(m3.end(), move(ip2));
    cout << "After the second move insertion, m3 contains:" << endl;
    print(m3);
    cout << endl;

    multimap<int, int> m4;
    // Insert the elements from an initializer_list
    m4.insert({ { 4, 44 }, { 2, 22 }, { 3, 33 }, { 1, 11 }, { 5, 55 } });
    cout << "After initializer_list insertion, m4 contains:" << endl;
    print(m4);
    cout << endl;
}

multimap::iterator

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

typedef implementation-defined iterator;

Замечания

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

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

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

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

Пример

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

multimap::key_comp

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

key_compare key_comp() const;

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

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

Замечания

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

bool operator( const Key& x, const Key& y);

значение true, если x строго предшествует в порядке сортировки y .

Пример

// multimap_key_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of m1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of m1."
           << endl;
   }

   multimap <int, int, greater<int> > m2;
   multimap <int, int, greater<int> >::key_compare kc2 = m2.key_comp( );
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of m2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of m2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of m1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of m2.

multimap::key_compare

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

typedef Traits key_compare;

Замечания

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

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

Пример

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

multimap::key_type

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

typedef Key key_type;

Замечания

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

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

Пример

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

multimap::lower_bound

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

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Параметры

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

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

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

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

Пример

// multimap_lower_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

   m1_RcIter = m1.lower_bound( 2 );
   cout << "The element of multimap m1 with a key of 2 is: "
        << m1_RcIter -> second << "." << endl;

   m1_RcIter = m1.lower_bound( 3 );
   cout << "The first element of multimap m1 with a key of 3 is: "
        << m1_RcIter -> second << "." << endl;

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

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

   // The element at a specific location in the multimap can be
   // found using a dereferenced iterator addressing the location
   m1_AcIter = m1.end( );
   m1_AcIter--;
   m1_RcIter = m1.lower_bound( m1_AcIter -> first );
   cout << "The first element of m1 with a key matching\n"
        << "that of the last element is: "
        << m1_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 ( m1_RcIter == --m1.end( ) )
      cout << "This is the last element of multimap m1."
           << endl;
   else
      cout << "This is not the last element of multimap m1."
           << endl;
}

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

multimap::mapped_type

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

typedef Type mapped_type;

Замечания

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

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

Пример

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

multimap::max_size

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

size_type max_size() const;

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

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

Пример

// multimap_max_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: size_type i;

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

multimap::multimap

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

multimap();

explicit multimap(
    const Traits& Comp);

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

map(
    const multimap& Right);

multimap(
    multimap&& Right);

multimap(
    initializer_list<value_type> IList);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

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

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

Параметры

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

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

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

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

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

IList
Объект initializer_list, из которого копируются элементы.

Замечания

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

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

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

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

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

Пятый конструктор задает копию multimap путем перемещения вправо.

6-й, 7-й и 8-й конструкторы копируют элементы объекта initializer_list.

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

Пример

// multimap_ctor.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

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

    // Create an empty multimap m0 of key type integer
    multimap <int, int> m0;

    // Create an empty multimap m1 with the key comparison
    // function of less than, then insert 4 elements
    multimap <int, int, less<int> > m1;
    m1.insert(Int_Pair(1, 10));
    m1.insert(Int_Pair(2, 20));
    m1.insert(Int_Pair(3, 30));
    m1.insert(Int_Pair(4, 40));

    // Create an empty multimap m2 with the key comparison
    // function of greater than, then insert 2 elements
    multimap <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

    // Create a multimap m3 with the
    // allocator of multimap m1
    multimap <int, int>::allocator_type m1_Alloc;
    m1_Alloc = m1.get_allocator();
    multimap <int, int> m3(less<int>(), m1_Alloc);
    m3.insert(Int_Pair(3, 30));

    // Create a copy, multimap m4, of multimap m1
    multimap <int, int> m4(m1);

    // Create a multimap m5 by copying the range m1[ first,  last)
    multimap <int, int>::const_iterator m1_bcIter, m1_ecIter;
    m1_bcIter = m1.begin();
    m1_ecIter = m1.begin();
    m1_ecIter++;
    m1_ecIter++;
    multimap <int, int> m5(m1_bcIter, m1_ecIter);

    // Create a multimap m6 by copying the range m4[ first,  last)
    // and with the allocator of multimap m2
    multimap <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    multimap <int, int> m6(m4.begin(), ++m4.begin(), less<int>(), m2_Alloc);

    cout << "m1 =";
    for (auto i : m1)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m2 =";
    for (auto i : m2)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m3 =";
    for (auto i : m3)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m4 =";
    for (auto i : m4)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m5 =";
    for (auto i : m5)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m6 =";
    for (auto i : m6)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m8 by copying in an initializer_list
    multimap<int, int> m8{ { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 } } };
    cout << "m8: = ";
    for (auto i : m8)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m9 with an initializer_list and a comparator
    multimap<int, int> m9({ { 5, 5 }, { 6, 6 }, { 7, 7 }, { 8, 8 } }, less<int>());
    cout << "m9: = ";
    for (auto i : m9)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m10 with an initializer_list, a comparator, and an allocator
    multimap<int, int> m10({ { 9, 9 }, { 10, 10 }, { 11, 11 }, { 12, 12 } }, less<int>(), m9.get_allocator());
    cout << "m10: = ";
    for (auto i : m10)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

}

multimap::operator=

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

multimap& operator=(const multimap& right);

multimap& operator=(multimap&& right);

Параметры

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

Замечания

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

Пример

// multimap_operator_as.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
   {
   using namespace std;
   multimap<int, int> v1, v2, v3;
   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;
   }

multimap::pointer

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

typedef typename allocator_type::pointer pointer;

Замечания

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

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

multimap::rbegin

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

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

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

Замечания

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

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

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

Пример

// multimap_rbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_rIter = m1.rbegin( );
   cout << "The first element of the reversed multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

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

   // A multimap element can be erased by dereferencing its key
   m1_rIter = m1.rbegin( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed multimap is "
        << m1_rIter -> first << "." << endl;
}

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

multimap::reference

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

typedef typename allocator_type::reference reference;

Пример

// multimap_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

   cout << "The data value of first element in the 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 multimap is 1.
The data value of first element in the multimap is 10.
The modified data value of first element is 15.

multimap::rend

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

const_reverse_iterator rend() const;

reverse_iterator rend();

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

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

Замечания

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

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

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

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

Пример

// multimap_rend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

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

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "The last element of the reversed multimap m1 is "
        << m1_rIter -> first << "." << endl;

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

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

   // A multimap element can be erased by dereferencing to its key
   m1_rIter = --m1.rend( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed multimap is "
        << m1_rIter -> first << "." << endl;
}

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

multimap::reverse_iterator

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

typedef std::reverse_iterator<iterator> reverse_iterator;

Замечания

Тип reverse_iterator используется для итерации в обратном multimap направлении.

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

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

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

Пример

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

multimap::size

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

size_type size() const;

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

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

Пример

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

// multimap_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    multimap<int, int> m1, m2;
    multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

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

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

The multimap length is 1.
The multimap length is now 2.

multimap::size_type

Целочисленный тип без знака, который подсчитывает количество элементов в объекте multimap.

typedef typename allocator_type::size_type size_type;

Пример

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

multimap::swap

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

void swap(
    multimap<Key, Type, Traits, Allocator>& right);

Параметры

right
Предоставление multimap элементов, которые необходимо заменить, или multimap элементы, которые необходимо обменять с элементами.multimapleft

Замечания

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

Пример

// multimap_swap.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2, m3;
   multimap <int, int>::iterator m1_Iter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );
   m2.insert ( Int_Pair ( 10, 100 ) );
   m2.insert ( Int_Pair ( 20, 200 ) );
   m3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   m1.swap( m2 );

   cout << "After swapping with m2, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( m1, m3 );

   cout << "After swapping with m3, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

The original multimap m1 is: 10 20 30.
After swapping with m2, multimap m1 is: 100 200.
After swapping with m3, multimap m1 is: 300.

multimap::upper_bound

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

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Параметры

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

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

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

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

Пример

// multimap_upper_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

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

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

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

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

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

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

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

multimap::value_comp

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

value_compare value_comp() const;

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

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

Замечания

multimapmЕсли два элемента e1(k1, d1) и e2(k2, d2) являются объектами типа value_type, где k1 и k2 являются их ключами типа key_type и d1d2 являются их данными типаmapped_type, то m.value_comp(e1, e2) эквивалентенm.key_comp(k1, k2).

Пример

// multimap_value_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   multimap<int,int>::iterator Iter1, Iter2;

   Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= m1.insert ( 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;
   }
}

The element ( 1,10 ) precedes the element ( 2,5 ).
The element ( 2,5 ) does not precede the element ( 1,10 ).

multimap::value_type

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

typedef pair<const Key, Type> value_type;

Пример

// multimap_value_type.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

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

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

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

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

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

   cout << "The data value of first element in the 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 = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

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

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

См. также

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