Класс `map`

Статья
06/16/2023

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

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

Синтаксис

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

Параметры

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

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

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

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

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

Замечания

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

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

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

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

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

Карта упорядочивает элементы, которые он управляет, вызывая хранимый объект функции типа 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<> предикат, не имеющий параметров типа. Дополнительные сведения см . в разделе "Разнородный поиск" в ассоциативных контейнерах .

Участники

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

Имя	Описание
`map`	Создание списка определенного размера или с элементами, обладающими указанным значением или указанным `allocator`, либо в качестве копии другого сопоставления.

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

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

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

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

Операторы

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

`allocator_type`

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

typedef Allocator allocator_type;

Пример

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

`at`

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

Type& at(const Key& key);

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

Параметры

key
Значение ключа, которое необходимо найти.

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

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

Замечания

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

Пример

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

typedef std::map<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// find and show elements
    std::cout << "c1.at('a') == " << c1.at('a') << std::endl;
    std::cout << "c1.at('b') == " << c1.at('b') << std::endl;
    std::cout << "c1.at('c') == " << c1.at('c') << std::endl;

    return (0);
    }

`begin`

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

const_iterator begin() const;

iterator begin();

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

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

Пример

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

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

   map <int, int> :: iterator m1_Iter;
   map <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 because the iterator is const
   // m1_cIter = m1.begin ( );
   // m1.erase ( m1_cIter );

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

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

`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

`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, не должно быть подвергнуто удалению ссылки.

`clear`

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

void clear();

Пример

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

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

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

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

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

`const_iterator`

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

typedef implementation-defined const_iterator;

Замечания

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

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

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

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

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

Пример

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

`const_pointer`

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

typedef typename allocator_type::const_pointer const_pointer;

Замечания

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

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

`const_reference`

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

typedef typename allocator_type::const_reference const_reference;

Пример

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

int main( )
{
   using namespace std;
   map <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 as 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 map 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 map is "
        << Ref2 << "." << endl;
}

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

`const_reverse_iterator`

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

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Замечания

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

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

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

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

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

Пример

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

`count`

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

size_type count(const Key& key) const;

Параметры

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

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

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

Замечания

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

[ lower_bound(ключ), upper_bound(ключ)

— 0 или 1 для map, который является уникальным ассоциативным контейнером.

Пример

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

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

int main()
{
    using namespace std;
    map<int, int> m1;
    map<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));

    // Keys must be unique in map, so duplicates are ignored
    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: 1.
The number of elements in m1 with a sort key of 2 is: 1.
The number of elements in m1 with a sort key of 3 is: 0.

`contains`

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

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::map<int, bool> m = {{0, true},{1, false}};

    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::map<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

`crbegin`

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

const_reverse_iterator crbegin() const;

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

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

Замечания

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

При возвращаемом значении crbeginmap объект нельзя изменить

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

Пример

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

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

   map <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 map m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed map m1 is 3.

`crend`

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

const_reverse_iterator crend() const;

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

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

Замечания

crend используется с обратной картой так же, как end и с map.

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

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

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

Пример

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

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

   map <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 map m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed map m1 is 1.

`difference_type`

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

typedef allocator_type::difference_type difference_type;

Замечания

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

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

Пример

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

int main( )
{
   using namespace std;
   map <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 ) );
   m1.insert ( Int_Pair ( 2, 30 ) );

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

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

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

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

`emplace`

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

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

Параметры

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

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

Компонент pair , компонент которого bool является true , если вставка была выполнена, и false если карта уже содержала элемент эквивалентного значения в порядке. Компонент итератора пары возвращаемых значений указывает на вставленный элемент, если значение компонента bool равно true, или на существующий элемент, если значение компонента bool равно false.

Для доступа к компоненту-итератору pairpr используйте pr.first; для разыменования его используйте *pr.first. Для доступа к компоненту bool используйте pr.second. См. пример кода далее в этой статье.

Замечания

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

При создании исключения состояние контейнера не изменяется.

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

Пример

// map_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: ";

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

    cout << endl;
}

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

    auto ret = m1.emplace(10, "ten");

    if (!ret.second){
        auto pr = *ret.first;
        cout << "Emplace failed, element with key 10 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
        cout << "map not modified" << endl;
    }
    else{
        cout << "map modified, now contains ";
        print(m1);
    }
    cout << endl;

    ret = m1.emplace(10, "one zero");

    if (!ret.second){
        auto pr = *ret.first;
        cout << "Emplace failed, element with key 10 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
    }
    else{
        cout << "map modified, now contains ";
        print(m1);
    }
    cout << endl;
}

`emplace_hint`

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

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

Параметры

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

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

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

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

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

Замечания

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

При создании исключения состояние контейнера не изменяется.

Пример

// map_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()
{
    map<string, string> m1;

    // Emplace some test data
    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

    cout << "map starting data: ";
    print(m1);
    cout << endl;

    // Emplace with hint
    // m1.end() should be the "next" element after this emplacement
    m1.emplace_hint(m1.end(), "Doug", "Engineering");

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

`empty`

Проверяет, что сопоставление пустое.

bool empty() const;

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

true Значение false Значение , если карта не является простой.

Пример

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

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

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

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

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

The map m1 is not empty.
The map m2 is empty.

`end`

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

const_iterator end() const;

iterator end();

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

Итератор после конца. Если карта пуста, то map::end() == map::begin().

Замечания

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

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

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

`equal_range`

Возвращает пару итераторов, представляющих lower_bound ключ и upper_bound ключ.

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

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

Параметры

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

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

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

Пример

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

int main( )
{
   using namespace std;
   typedef map <int, int, less<int> > IntMap;
   IntMap m1;
   map <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 <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
   p1 = m1.equal_range( 2 );

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

   cout << "The upper bound of the element with "
        << "a key of 2 in the map 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 map m1 doesn't have an element "
           << "with a key less than 40." << endl;
   else
      cout << "The element of map m1 with a key >= 40 is: "
           << p2.first -> first << "." << endl;
}

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

`erase`

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

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Параметры

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

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

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

Key
Значение ключа удаляемых элементов.

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

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

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

Пример

// map_erase.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>
#include <iterator> // next() and prev() helper functions
#include <utility>  // make_pair()

using namespace std;

using mymap = map<int, string>;

void printmap(const mymap& m) {
    for (const auto& elem : m) {
        cout << " [" << elem.first << ", " << elem.second << "]";
    }
    cout << endl << "size() == " << m.size() << endl << endl;
}

int main()
{
    mymap m1;

    // Fill in some data to test with, one at a time
    m1.insert(make_pair(1, "A"));
    m1.insert(make_pair(2, "B"));
    m1.insert(make_pair(3, "C"));
    m1.insert(make_pair(4, "D"));
    m1.insert(make_pair(5, "E"));

    cout << "Starting data of map m1 is:" << endl;
    printmap(m1);
    // The 1st member function removes an element at a given position
    m1.erase(next(m1.begin()));
    cout << "After the 2nd element is deleted, the map m1 is:" << endl;
    printmap(m1);

    // Fill in some data to test with, one at a time, using an initializer list
    mymap m2
    {
        { 10, "Bob" },
        { 11, "Rob" },
        { 12, "Robert" },
        { 13, "Bert" },
        { 14, "Bobby" }
    };

    cout << "Starting data of map m2 is:" << endl;
    printmap(m2);
    // The 2nd member function removes elements
    // in the range [First, Last)
    m2.erase(next(m2.begin()), prev(m2.end()));
    cout << "After the middle elements are deleted, the map m2 is:" << endl;
    printmap(m2);

    mymap m3;

    // Fill in some data to test with, one at a time, using emplace
    m3.emplace(1, "red");
    m3.emplace(2, "yellow");
    m3.emplace(3, "blue");
    m3.emplace(4, "green");
    m3.emplace(5, "orange");
    m3.emplace(6, "purple");
    m3.emplace(7, "pink");

    cout << "Starting data of map m3 is:" << endl;
    printmap(m3);
    // The 3rd member function removes elements with a given Key
    mymap::size_type count = m3.erase(2);
    // The 3rd member function also returns the number of elements removed
    cout << "The number of elements removed from m3 is: " << count << "." << endl;
    cout << "After the element with a key of 2 is deleted, the map m3 is:" << endl;
    printmap(m3);
}

`find`

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

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Параметры

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

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

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

Замечания

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

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

Пример

// 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()
{
    map<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting map 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 map m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

`get_allocator`

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

allocator_type get_allocator() const;

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

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

Замечания

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

Пример

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

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

   // The following lines declare objects
   // that use the default allocator.
   map <int, int> m1;
   map <int, int, allocator<int> > m2;
   map <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\n"
        << "before free memory is exhausted: "
        << m2.max_size( ) << ".\n" << endl;

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

   // The following line creates a map m4
   // with the allocator of map 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 with the other
   if( m1_Alloc == m4_Alloc )
   {
      cout << "The allocators are interchangeable." << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable." << endl;
   }
}

`insert`

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

// (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
Значение элемента для вставки в карту, если он еще не содержит элемент, ключ которого эквивалентно упорядочен.

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

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

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

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

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

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

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

Функции-члены с одним элементом (1) и (2) возвращают pair компонент, компонент которого bool имеет значение true, если вставка была выполнена, и значение false, если карта уже содержала элемент, ключ которого имел эквивалентное значение в порядке. Компонент итератора пары возвращаемых значений указывает на вставленный элемент, если значение компонента bool равно true, или на существующий элемент, если значение компонента bool равно false.

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

Замечания

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

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

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

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

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

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

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

Пример

// map_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
    map<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
    auto ret = m1.insert(make_pair(1, 111));
    if (!ret.second){
        auto pr = *ret.first;
        cout << "Insert failed, element with key value 1 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
    }
    else{
        cout << "The modified key and mapped values of m1 are:" << endl;
        print(m1);
    }
    cout << endl;

    // 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
    map<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
    map<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;

    map<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;
}

`iterator`

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

typedef implementation-defined iterator;

Замечания

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

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

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

Пример

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

`key_comp`

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

key_compare key_comp() const;

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

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

Замечания

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

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

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

Пример

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

int main( )
{
   using namespace std;

   map <int, int, less<int> > m1;
   map <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;
   }

   map <int, int, greater<int> > m2;
   map <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.

`key_compare`

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

typedef Traits key_compare;

Замечания

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

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

Пример

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

`key_type`

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

typedef Key key_type;

Замечания

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

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

Пример

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

`lower_bound`

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

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Параметры

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

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

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

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

Пример

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

int main( )
{
   using namespace std;
   map <int, int> m1;
   map <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_RcIter = m1.lower_bound( 2 );
   cout << "The first element of map m1 with a key of 2 is: "
        << m1_RcIter -> second << "." << endl;

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

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

   // The element at a specific location in the map 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 element of m1 with a key matching "
        << "that of the last element is: "
        << m1_RcIter -> second << "." << endl;
}

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

`map`

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

map();

explicit map(
    const Traits& Comp);

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

map(
    const map& Right);

map(
    map&& Right);

map(
    initializer_list<value_type> IList);

map(
    initializer_list<value_type> IList,
    const Traits& Comp);

map(
    initializer_list<value_type> IList,
    const Traits& Comp,
    const Allocator& Allocator);

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

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

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

Параметры

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

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

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

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

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

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

Замечания

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

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

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

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

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

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

6-й, 7-й и 8-й конструкторы используют конструкторы initializer_list , из которых копируются элементы.

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

Пример

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

int main()
{
    using namespace std;
    typedef pair <int, int> Int_Pair;
    map <int, int>::iterator m1_Iter, m3_Iter, m4_Iter, m5_Iter, m6_Iter, m7_Iter;
    map <int, int, less<int> >::iterator m2_Iter;

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

    // Create an empty map m1 with the key comparison
    // function of less than, then insert 4 elements
    map <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 map m2 with the key comparison
    // function of greater than, then insert 2 elements
    map <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

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

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

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

    // Create a map m6 by copying the range m4[ first,  last)
    // and with the allocator of map m2
    map <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    map <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 map m7 by moving m5
    cout << "m7 =";
    map<int, int> m7(move(m5));
    for (auto i : m7)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m8 by copying in an initializer_list
    map<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 map m9 with an initializer_list and a comparator
    map<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 map m10 with an initializer_list, a comparator, and an allocator
    map<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;
}

`mapped_type`

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

typedef Type mapped_type;

Замечания

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

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

Пример

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

`max_size`

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

size_type max_size() const;

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

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

Пример

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

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

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

`operator[]`

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

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

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

Параметры

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

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

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

Замечания

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

operator[] можно использовать для вставки элементов в сопоставление m с помощью m[key] = DataValue;, где DataValue — это значение элемента mapped_type со значением ключа key.

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

Пример

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

int main( )
{
   using namespace std;
   typedef pair <const int, int> cInt2Int;
   map <int, int> m1;
   map <int, int> :: iterator pIter;

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

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

   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;

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

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

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

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

// insert by moving key
    map<string, int> c2;
    string str("abc");
    cout << "c2[move(str)] == " << c2[move(str)] << endl;
    cout << "c2["abc"] == " << c2["abc"] << endl;

    return (0);
}

The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.
The keys of the mapped elements are now: 1 2 3 5.
The values of the mapped elements are now: 10 40 30 0.
c2[move(str)] == 0
c2["abc"] == 1

`operator=`

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

map& operator=(const map& right);
map& operator=(map&& right);

Параметры

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

Замечания

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

Пример

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

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

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

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

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

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

`pointer`

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

typedef typename allocator_type::pointer pointer;

Замечания

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

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

rbegin

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

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

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

Замечания

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

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

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

Пример

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

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

   map <int, int> :: iterator m1_Iter;
   map <int, int> :: reverse_iterator m1_rIter;
   map <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 map m1 is "
        << m1_rIter -> first << "." << endl;

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

   // A map element can be erased by dereferencing to 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 map is "
        << m1_rIter -> first << "." << endl;
}

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

`reference`

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

typedef typename allocator_type::reference reference;

Пример

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

int main( )
{
   using namespace std;
   map <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 map 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 map is "
        << Ref2 << "." << endl;

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

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

`rend`

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

const_reverse_iterator rend() const;

reverse_iterator rend();

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

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

Замечания

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

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

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

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

Пример

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

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

   map <int, int> :: iterator m1_Iter;
   map <int, int> :: reverse_iterator m1_rIter;
   map <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 map m1 is "
        << m1_rIter -> first << "." << endl;

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

   // A map 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 map is "
        << m1_rIter -> first << "." << endl;
}

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

`reverse_iterator`

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

typedef std::reverse_iterator<iterator> reverse_iterator;

Замечания

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

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

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

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

Пример

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

`size`

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

size_type size() const;

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

Текущая длина сопоставления.

Пример

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

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

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

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

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

The map length is 1.
The map length is now 2.

`size_type`

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

typedef typename allocator_type::size_type size_type;

Пример

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

swap

Обмен элементами между двумя сопоставлениями.

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

Параметры

right
Сопоставление-аргумент предоставляет элементы для обмена с целевым сопоставлением.

Замечания

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

Пример

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

int main( )
{
   using namespace std;
   map <int, int> m1, m2, m3;
   map <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 map 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
   //m2 is said to be the argument map; m1 the target map
   m1.swap( m2 );

   cout << "After swapping with m2, map 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, map m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

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

`upper_bound`

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

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Параметры

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

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

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

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

Пример

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

int main( )
{
   using namespace std;
   map <int, int> m1;
   map <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_RcIter = m1.upper_bound( 2 );
   cout << "The first element of map 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. upper_bound ( 4 );

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

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

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

`value_comp`

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

value_compare value_comp() const;

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

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

Замечания

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

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

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

Пример

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

int main( )
{
   using namespace std;

   map <int, int, less<int> > m1;
   map <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   pair< map<int,int>::iterator, bool > pr1, pr2;

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

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

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

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

`value_type`

Тип объекта, хранящегося в качестве элемента в сопоставлении.

typedef pair<const Key, Type> value_type;

Пример

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

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

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

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

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

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

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

   // The following line would cause an error because
   // the value_type isn't 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;
}

См. также

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