Как вывести map c

Карта или std::map представляет контейнер, где каждое значение ассоциировано с определенным ключом. И по этому ключу можно получить элемент. Причем ключи могут иметь только уникальные значения. Примером такого контейнера может служить словарь, где каждому слову сопоставляется его перевод или объяснение. Поэтому такие структуры еще называют словарями.

Стандартная библиотека C++ предоставляет два типа словарей: std::map и std::unordered_map . Эти типы представляют шаблоны, которые типизируются двумя типами. Первый тип — Key задает тип для ключей, а второй тип — Value устанавливает тип для значений.

Тип std::map определен в заголовочном файле . Определение пустого словаря:

#include #include int main() < std::mapproducts; >

Здесь определен словарь products, который будет условно хранить цену товаров. Для ключей будет применяться тип std::string , а для значений — числа типа unsigned (условно в качестве ключа будет выступать название товара, а в качестве значения — его цена).

Обращение к элементам

Для обращения к элементам словаря — получения или изменения их значений, так же, как в массиве или векторе, применяется оператора индексирования [] . Только вместо целочисленных индексов можно использовать ключи любого типа в следующем виде:

map[ключ]=значение

#include #include int main() < std::mapproducts; // установка значений products["bread"] = 30; products["milk"] = 80; products["apple"] = 60; // получение значений std::cout

Здесь определен словарь products, в котором ключами служат строки, а значениями — числа типа unsigned. Поэтому для установки элемента в квадратные скобки передается ключ-строка, а присваивается значение-число:

products["bread"] = 30;

Будем считать, что ключ — название товара, а значение — цена товара. То есть в данном случае элементу с ключом «bread» присваивается значение 30. При этом не важно, что ранее создан пустой словарь, и в нем нет никакого элемента с ключом «bread» — если его нет, то он создается. Если же элемент с данным ключом уже есть, то меняется его значение.

Чтобы получить элемент по определенному ключу, используем тот же синтаксис. Например, поскольку значение элемента — число, то мы можем, обратившись по ключу, получить это число:

unsigned breadPrice = products["bread"];

В выше приведенной программе просто выводим значения элементов на консоль:

bread 30 milk 80 apple 60

Перебор элементов:

Для перебора элементов можно применять цикл for в стиле «for-each»:

#include #include int main() < std::mapproducts; // установка значений products["bread"] = 30; products["milk"] = 80; products["apple"] = 60; for (const auto& [product, price] : products) std::cout

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

for (const auto& element : products) std::cout 
Но начиная со стандарта С++17 также можно использовать другой синтаксис, который позволяет сразу разложить объект на отдельные части - ключ и значение:
for (const auto& [product, price] : products) std::cout 
В данном случае в product будет помещаться ключ, а в price - значение элемента словаря. В итоге при выполнении программы мы получим следующий консольный вывод:
apple 60 bread 30 milk 80
Обратите внимание, что элементы располагаются в словаре и соответственно выводятся на консоль по возрастанию ключей. Поскольку ключи представляют строки, то они сортируются в алфавитном порядке.
Инициализация элементов
Тот факт, что в словаре элементы представляют тип std::pair, позволяет инициализировать словарь объектами std::pair:
#include #include int main() < std::mapproducts < std::pair, std::pair, std::pair >; >
И даже можно сократить определение:
#include #include int main() < std::mapproducts < , , >; >
Удаление элементов
Как было показано выше, для добавления элемента в словарь достаточно просто установить для некоторого ключа какой-нибудь значение. Для удаления же элементов применяется функция erase() , в которую передается ключ удаляемого элемента:
#include #include int main() < std::mapproducts < , , >; products.erase("milk"); // удаляем элемент с ключом "milk" for (const auto& [product, price] : products) std::cout 
Размер словаря
Для получения количества элементов в словаре применяется функция size() . Также класс map имеет функцию empty() , которая возвращает true , если словарь пуст.
#include #include int main() < std::mapproducts < , , >; std::cout 
Проверка наличия элемента
Чтобы проверить, есть ли в словаре элемент с определенным ключом, применяются функции count() (возвращает 1, если элемент есть, и 0 - если отсутствует) и contains() (возвращает true, если элемент есть, и false - если отсутствует). В обе функции передается ключ элемента:
#include #include int main() < std::mapproducts < std::pair, std::pair, std::pair >; std::cout 
Неупорядоченные словари
Тип std::map определяет словарь, который упорядочиваниет все свои элементы - по умолчанию в порядке возрастания ключей. Если упорядоченность не нужна, можно применять ти std::unordered_map , который в целом предоставляет тот же самый функционал, только не упорядочивает элементы и определен в заголовочном файле
#include #include int main() < std::unordered_mapproducts < std::pair, std::pair, std::pair >; for (const auto& [product, price] : products) std::cout
apple 60 milk 80 bread 30
Итераторы
Стоит отметить, что итераторы типа std::map являеются константными, что не позволяет изменять значения элементов при переборе:
#include #include int main() < std::mapphoneBook < , , >; for(auto iter; iter != phoneBook.end(); iter++) < std::cout first << "\t" second // для получения итераторов также можно использовать функции cbegin и cend for(auto iter; iter != phoneBook.cend(); iter++) < std::cout first << "\t" second >
Как вывести на экран все значения элементов лежащих по одному ключу в std::map?
Как вывести на экран все значения элементов лежащих по одному ключу в std::map? вот у меня есть контейнер std::map, в нем содержится: 
merlok 89-09-23 
merlok 66-66-66 
merlok 12-34-56 
задача вывести все номера по ключу surname, где surname это merlok
#include #include #include struct data < std::string number; std::string surname; >user; void add(std::map& surname_book, std::map& phone_book) < while (1) < std::cout > user.number; if (user.number == "0") < system("cls"); break; >std::cout > user.surname; phone_book.insert( std::pair(user.number, user.surname)); surname_book.insert( std::pair(user.number, user.surname)); > > void search_by_surname(std::map& surname_book) < std::string surname; std::cout > surname; std::map::iterator it = surname_book.begin(); if (it == surname_book.end()) < std::cout else < std::cout first > > void search_by_number(std::map& phone_book) < std::string number; std::cout > number; std::map::iterator it = phone_book.find(number); std::cout << "Founds:\n"; if (it == phone_book.end()) < std::cout else < std::cout first << " " second > int main() < std::mapsurnameBook; std::map phoneBook; while (1) < std::cout > choice; if (choice == "0") < system("cls"); break; >if (choice == "add") < add(surnameBook, phoneBook); >else if (choice == "find") < std::cout > ans; switch (ans) < case 1: search_by_number(phoneBook); break; case 2: search_by_surname(surnameBook); break; >system("pause"); system("cls"); > > std::cout

Вопрос задан более двух лет назад
411 просмотров

1 комментарий
Простой 1 комментарий

logan baby @loganbaby Автор вопроса

и сделать это за O(logN).

Решения вопроса 0

Ответы на вопрос 2

Для правильного вопроса надо знать половину ответа
ЕМНИП, у std:map не может быть нескольких элементов с одним ключом. Так что просто 
surname_book.find(surname)
Ответ написан более двух лет назад

logan baby @loganbaby Автор вопроса
я неверно поставил вопрос. взгляните на код, при вводе add надо ввести "номер телефона" и "фамилию". что то типо телефонной книги. я могу ввести также одинаковые фамилии на разные номера телефонов, но не одинаковые номера телефонов на разные фамилии. как их вывести за logN? с циклом (как у меня) получается за O(N), в этом и заключалась суть вопроса)))
#include #include #include struct data < std::string number; std::string surname; >user; void add(std::map& surname_book, std::map& phone_book) < while (1) < std::cout > user.number; if (user.number == "0") < system("cls"); break; >std::cout > user.surname; phone_book.insert( std::pair(user.number, user.surname)); surname_book.insert( std::pair(user.number, user.surname)); > > void search_by_surname(std::map& surname_book) < std::string surname; std::cout > surname; std::map::iterator it = surname_book.begin(); if (it == surname_book.end()) < std::cout else < std::cout first > > void search_by_number(std::map& phone_book) < std::string number; std::cout > number; std::map::iterator it = phone_book.find(number); std::cout << "Founds:\n"; if (it == phone_book.end()) < std::cout else < std::cout first << " " second > int main() < std::mapsurnameBook; std::map phoneBook; while (1) < std::cout > choice; if (choice == "0") < system("cls"); break; >if (choice == "add") < add(surnameBook, phoneBook); >else if (choice == "find") < std::cout > ans; switch (ans) < case 1: search_by_number(phoneBook); break; case 2: search_by_surname(surnameBook); break; >system("pause"); system("cls"); > > std::cout
Класс map
Используется для хранения и извлечения данных из коллекции, в которой каждый элемент является парой, обладающей одновременно значением данных и ключом сортировки. Значение ключа уникально и применяется для автоматической сортировки данных.
Значение элемента в сопоставлении можно изменить напрямую. Значение ключа является константой и не может быть изменено. Вместо этого значения ключей, связанные со старыми элементами, необходимо удалить и вставить новые значения ключей для новых элементов.
Синтаксис
template , class Allocator=allocator>> class map; 
Параметры
 Key 
Тип данных ключа, который должен храниться в объекте map .
 Type 
Тип данных элемента для сохранения в map .
 Traits 
Тип, предоставляющий объект функции, который может сравнить два значения элементов в виде ключей сортировки, чтобы определить их относительный порядок в . map Этот аргумент является необязательным, и в качестве значения по умолчанию используется бинарный предикат less .
В C++14 можно включить разнородный поиск, указав std::less<> предикат, не имеющий параметров типа. Дополнительные сведения см . в разделе "Разнородный поиск" в ассоциативных контейнерах .
 Allocator 
Тип, представляющий сохраненный объект распределителя, который инкапсулирует сведения о выделении и освобождении памяти для сопоставления. Этот аргумент является необязательным, и значением по умолчанию является allocator > .
Замечания
Класс map в стандартной библиотеке С++ — это:

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

Итератор, предоставляемый классом карты, является двунаправленным итератором, но insert map функции-члены класса имеют версии, которые принимают в качестве параметров шаблона более слабый итератор входных данных, требования к функциональным возможностям которых меньше, чем те, которые гарантированы классом двунаправленных итераторов. Различные концепции итераторов связаны уточнениями функциональности. Каждая концепция итератора обладает собственным набором требований, и совместимые с ней алгоритмы должны быть ограничены этими требованиями. Итератор ввода может быть разыменован для обращения к определенному объекту и инкрементирован следующему итератору в последовательности.
Рекомендуется выбирать тип контейнера на основе типа поиска и вставки, который требуется приложению. Ассоциативные контейнеры оптимизированы для операций поиска, вставки и удаления. Функции-члены, которые явно поддерживают эти операции, выполняют их в худшем случае, пропорционально логарифму количества элементов в контейнере. Вставка элементов не делает итераторы недействительными, а при удалении элементов недействительными становятся только итераторы, указывающие конкретно на удаленные элементы.
Рекомендуется сделать сопоставление предпочтительным ассоциативным контейнером, где условия, ассоциирующие значения с ключами, удовлетворяют требованиям приложения. Модель для этого типа структуры представляет собой упорядоченный список уникальных ключевых слов, с которыми связаны значения строк, предоставляющие определения. Если слово имеет несколько правильных определений, чтобы ключ не был уникальным, то многозначный объект будет контейнером. Если сохранен обычный список слов, подходящим контейнером будет набор. Если допускается многократное использование слов, допустимым вариантом будет множественный набор.
Карта упорядочивает элементы, которые он управляет, вызывая хранимый объект функции типа 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_allocator allocator_type .
at
Поиск элемента с заданным значением ключа.
Type& at(const Key& key); const Type& at(const Key& key) const; 
Параметры
 key 
Значение ключа, которое необходимо найти.
Возвращаемое значение
Ссылка на значение данных найденного элемента.
Замечания
Если значение ключа аргумента не найдено, функция создает объект класса Class out_of_range .
Пример
// map_at.cpp // compile with: /EHsc #include #include typedef std::map 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
begin
Возвращает итератор, обращающийся к первый элемент в контейнере map .
const_iterator begin() const; iterator begin(); 
Возвращаемое значение
Двунаправленный итератор, обращаюющийся к первому элементу в map расположении или расположению, успешно выполнена пустая карта.
Пример
// map_begin.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map m1; map :: iterator m1_Iter; map :: const_iterator m1_cIter; typedef pair 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 first first
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::iterator auto i2 = Container.cbegin(); // i2 is Container::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::iterator auto i2 = Container.cend(); // i2 is Container::const_iterator 
Значение, возвращаемое cend , не должно быть подвергнуто удалению ссылки.
clear
Стирает все элементы в сопоставлении.
void clear(); 
Пример
В следующем примере показано использование map::clear функции-члена.
// map_clear.cpp // compile with: /EHsc #include #include int main() < using namespace std; mapm1; map::size_type i; typedef pair 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 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 чей первый член является ключом к элементу и чей второй член является сопоставленным datum, удерживаемым элементом.
Для разыменования const_iterator cIter , указывающего на элемент в сопоставлении, используйте оператор -> .
Чтобы получить доступ к значению ключа для элемента, используйте cIter значение -> first , эквивалентное (* cIter ). first .
Чтобы получить доступ к значению сопоставленной datum для элемента, используйте cIter значение -> second , эквивалентное (* cIter ). second .
Пример
Пример использования см. в примере begin const_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 #include int main( ) < using namespace std; map m1; typedef pair 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 second ); cout
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_reverse_iterator; 
Замечания
Тип const_reverse_iterator не может изменить значение элемента и используется для итерации по карте в обратном направлении.
Определяется const_reverse_iterator сопоставлением элементов, которые являются объектами value_type типа, pair чей первый член является ключом к элементу и чей второй член является сопоставленным 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 в диапазоне
— 0 или 1 для map, который является уникальным ассоциативным контейнером.
Пример
В следующем примере показано использование map::count функции-члена.
// map_count.cpp // compile with: /EHsc #include #include int main() < using namespace std; mapm1; map::size_type i; typedef pair 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: 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 bool contains(const K& key) const; 
Параметры
 key 
Значение ключа элемента для поиска.
Возвращаемое значение
true Значение , если элемент найден в контейнере; false Иначе.
Замечания
contains() новый в C++20. Чтобы использовать его, укажите или более поздний /std:c++20 параметр компилятора.
template bool contains(const K& key) const только принимает участие в разрешении перегрузки, если key_compare это прозрачно. Дополнительные сведения см . в разнородном поиске в ассоциативных контейнерах .
Пример
// Requires /std:c++20 or /std:c++latest #include #include #include #include int main() < std::mapm = ,>; std::cout > m2 = , , >; std::cout
true false true 
crbegin
Возвращает константный итератор на первый элемент в обратной карте.
const_reverse_iterator crbegin() const; 
Возвращаемое значение
Констант обратный двунаправленный итератор, обращаюющийся к первому элементу в обратном или map адресующий то, что было последним элементом в необратимом map .
Замечания
crbegin используется с обратным map так же, как begin используется с map .
При возвращаемом значении crbegin map объект нельзя изменить
crbegin можно использовать для перебора map в обратном порядке.
Пример
// map_crbegin.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map m1; map :: const_reverse_iterator m1_crIter; typedef pair 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 first
The first element of the reversed map m1 is 3. 
crend
Возвращает константный итератор, адресующий положение после последнего элемента в обратном сопоставлении.
const_reverse_iterator crend() const; 
Возвращаемое значение
Обратный двунаправленный итератор констант, который обращается к расположению, успешному последнему элементу в обратном map направлении (расположение, предшествовающее первому элементу в непровернутом map ).
Замечания
crend используется с обратной картой так же, как end и с map .
Возвращаемое значение crend map объекта невозможно изменить.
crend используется, чтобы проверить, достиг ли итератор конца map .
Значение, возвращаемое crend , не должно быть подвергнуто удалению ссылки.
Пример
// map_crend.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map m1; map :: const_reverse_iterator m1_crIter; typedef pair 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 first
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 #include #include int main( ) < using namespace std; map m1; typedef pair 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 ::iterator m1_Iter, m1_bIter, m1_eIter; m1_bIter = m1.begin( ); m1_eIter = m1.end( ); // Count the number of elements in a map map ::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: 4. 
emplace
Вставляет в сопоставление элемент, созданный на месте (без выполнения операций копирования или перемещения).
template pair emplace( Args&&. args); 
Параметры
 args 
Аргументы, пересылаемые для создания элемента для вставки в карту, если он еще не содержит элемент, значение которого эквивалентно упорядочено.
Возвращаемое значение
Компонент pair , компонент которого bool является true , если вставка была выполнена, и false если карта уже содержала элемент эквивалентного значения в порядке. Компонент итератора пары возвращаемых значений указывает на вставленный элемент, если значение компонента bool равно true, или на существующий элемент, если значение компонента bool равно false.
Для доступа к компоненту-итератору pair pr используйте pr.first ; для разыменования его используйте *pr.first . Для доступа к компоненту bool используйте pr.second . См. пример кода далее в этой статье.
Замечания
Эта функция не делает недействительными никакие итераторы или ссылки.
При создании исключения состояние контейнера не изменяется.
Элемент value_type является парой, поэтому значение элемента будет упорядоченной парой с первым компонентом, равным значению ключа, и второй компонент равен значению данных элемента.
Пример
// map_emplace.cpp // compile with: /EHsc #include #include #include using namespace std; template void print(const M& m) < cout cout int main() < mapm1; 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" else < cout 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 << ")" else < cout cout
emplace_hint
Вставляет созданный элемент на место (операции копирования или перемещения не выполняются) с указанием о размещении.
template iterator emplace_hint( const_iterator where, Args&&. args); 
Параметры
 args 
Аргументы, пересылаемые для создания элемента для вставки в карту, если карта уже не содержит этот элемент или, как правило, если он уже не содержит элемент, ключ которого эквивалентно упорядочен.
 where 
Место начала поиска правильной точки вставки. (Если эта точка сразу же предшествует , вставка может происходить в амортизированном времени константы вместо логарифмического времени.)
Возвращаемое значение
Итератор, указывающий на вновь вставленный элемент.
Если вставка не удалась, так как элемент уже существует, возвращается итератор, указывающий на существующий элемент с его ключом.
Замечания
Эта функция не делает недействительными никакие итераторы или ссылки.
При создании исключения состояние контейнера не изменяется.
Элемент value_type является парой, поэтому значение элемента будет упорядоченной парой с первым компонентом, равным значению ключа, и второй компонент равен значению данных элемента.
Пример
// map_emplace.cpp // compile with: /EHsc #include #include #include using namespace std; template void print(const M& m) < cout cout int main() < mapm1; // Emplace some test data m1.emplace("Anna", "Accounting"); m1.emplace("Bob", "Accounting"); m1.emplace("Carmine", "Engineering"); cout 
empty
Проверяет, что сопоставление пустое.
bool empty() const; 
Возвращаемое значение
 true Значение false Значение , если карта не является простой.
Пример
// map_empty.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map m1, m2; typedef pair Int_Pair; m1.insert ( Int_Pair ( 1, 1 ) ); if ( m1.empty( ) ) cout
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 equal_range (const Key& key) const; pair equal_range (const Key& key); 
Параметры
 key 
Ключевое значение для сравнения с ключом сортировки элемента из сопоставления, в котором ведется поиск.
Возвращаемое значение
Для доступа к первому итератору пары pr , возвращаемой функцией-членом, нужно использовать pr . во-первых, и для разыменовки нижнего итератора итератора используйте *( pr . сначала). Для доступа к второму итератору пары pr , возвращаемой функцией-членом, нужно использовать pr . во-вторых, и для разыменовки итератора верхнего границы используйте *( pr . во-вторых).
Пример
// map_equal_range.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; typedef map > IntMap; IntMap m1; map :: const_iterator m1_RcIter; typedef pair Int_Pair; m1.insert ( Int_Pair ( 1, 10 ) ); m1.insert ( Int_Pair ( 2, 20 ) ); m1.insert ( Int_Pair ( 3, 30 ) ); pair p1, p2; p1 = m1.equal_range( 2 ); cout second second second = 40 is: " first
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 #include #include #include // next() and prev() helper functions #include // make_pair() using namespace std; using mymap = map; void printmap(const mymap& m) < for (const auto& elem : m) < cout cout 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 , < 11, "Rob" >, < 12, "Robert" >, < 13, "Bert" >, < 14, "Bobby" >>; cout 
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 #include #include #include #include // make_pair() using namespace std; template void print_elem(const pair& p) < cout template void print_collection(const T& t) < cout cout template 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 else < cout << "Element not found." > int main() < mapm1(< < 40, "Zr" >, < 45, "Rh" >>); cout << "The starting map m1 is (key, value):" << endl; print_collection(m1); vector 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
get_allocator
Возвращает копию объекта-распределителя, использованного для создания сопоставления.
allocator_type get_allocator() const; 
Возвращаемое значение
Распределитель, используемый сопоставлением.
Замечания
Распределители для класса map определяют, как это класс управляет памятью. Распределители по умолчанию для классов контейнеров из стандартной библиотеки C++ достаточны для большинства задач программирования. Написание и использование собственного класса распределителя требует расширенных навыков работы с C++.
Пример
// map_get_allocator.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map ::allocator_type m1_Alloc; map ::allocator_type m2_Alloc; map ::allocator_type m3_Alloc; map ::allocator_type m4_Alloc; // The following lines declare objects // that use the default allocator. map m1; map > m2; map > 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 m4( less( ), 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 else < cout > 
insert
Вставляет элемент или диапазон элементов в сопоставление.
// (1) single element pair insert( const value_type& Val); // (2) single element, perfect forwarded template pair 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 iterator insert( const_iterator Where, ValTy&& Val); // (5) range template void insert( InputIterator First, InputIterator Last); // (6) initializer list void insert( initializer_list 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) возвращают итератор, который указывает на позицию, где новый элемент был вставлен, или, если элемент с эквивалентным ключом уже существует, указывает на существующий элемент.
Замечания
Эта функция не делает никакие итераторы, указатели или ссылки недействительными.
Во время вставки только одного элемента, если создается исключение, состояние контейнера не изменяется. Если во время вставки нескольких элементов вызывается исключение, контейнер остается в неопределенном, но допустимом состоянии.
Для доступа к компоненту итератора pair pr , возвращаемого одноэлементными функциями-членами, используйте pr.first . Для разыменования итератора в возвращенной паре используйте *pr.first , чтобы получить элемент. Для доступа к компоненту bool используйте pr.second . См. пример кода далее в этой статье.
Контейнер value_type представляет собой типдифакт, который принадлежит контейнеру, а для сопоставления map::value_type — pair . Значение элемента — это упорядоченная пара, в которой первый компонент эквивалентен значению ключа, а второй компонент — значению данных элемента.
Функция-член с диапазоном (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 #include #include #include #include // make_pair() using namespace std; template void print(const M& m) < cout cout int main() < // insert single values mapm1; // 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 << ")" else < cout 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 mapm2; vector 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 m3; pair 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; mapm4; // Insert the elements from an initializer_list m4.insert(< < 4, 44 >, < 2, 22 >, < 3, 33 >, < 1, 11 >, < 5, 55 >>); cout
iterator
Тип, предоставляющий двунаправленный итератор, который может считывать или изменять любой элемент в сопоставлении.
typedef implementation-defined iterator; 
Замечания
Итератор, определенный картой, указывает на элементы, которые являются объектами value_type типа, pair первый член которого является ключом к элементу и второй член которого является сопоставленным datum, удерживаемым элементом.
Чтобы разыменовать итератор итератора , указывающий на элемент в карте, используйте -> оператор.
Чтобы получить доступ к значению ключа для элемента, используйте Iter->first , что эквивалентно (*Iter).first . Чтобы получить доступ к значению сопоставленной datum для элемента, используйте Iter->second эквивалент (*Iter).second .
Пример
Пример объявления и использования iterator см. в примере begin .
key_comp
Извлекает копию объекта сравнения, использованного для упорядочивания ключей в сопоставлении.
key_compare key_comp() const; 
Возвращаемое значение
Возвращает объект-функцию, которую сопоставление использует для упорядочивания своих элементов.
Замечания
Хранимый объект определяет функцию-член
значение , которое возвращается true , если left предшествует и не равно right в порядке сортировки.
Пример
// map_key_comp.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map > m1; map >::key_compare kc1 = m1.key_comp( ) ; bool result1 = kc1( 2, 3 ) ; if( result1 == true ) < cout else < cout map > m2; map >::key_compare kc2 = m2.key_comp( ); bool result2 = kc2( 2, 3 ) ; if( result2 == true ) < cout else < cout > 
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 #include int main( ) < using namespace std; map m1; map :: const_iterator m1_AcIter, m1_RcIter; typedef pair 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 second second first ); cout second
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 IList); map( initializer_list IList, const Traits& Comp); map( initializer_list IList, const Traits& Comp, const Allocator& Allocator); template map( InputIterator First, InputIterator Last); template map( InputIterator First, InputIterator Last, const Traits& Comp); template 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 #include int main() < using namespace std; typedef pair Int_Pair; map ::iterator m1_Iter, m3_Iter, m4_Iter, m5_Iter, m6_Iter, m7_Iter; map >::iterator m2_Iter; // Create an empty map m0 of key type integer map m0; // Create an empty map m1 with the key comparison // function of less than, then insert 4 elements map > 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 > m2; m2.insert(Int_Pair(1, 10)); m2.insert(Int_Pair(2, 20)); // Create a map m3 with the // allocator of map m1 map ::allocator_type m1_Alloc; m1_Alloc = m1.get_allocator(); map m3(less(), m1_Alloc); m3.insert(Int_Pair(3, 30)); // Create a copy, map m4, of map m1 map m4(m1); // Create a map m5 by copying the range m1[ first, last) map ::const_iterator m1_bcIter, m1_ecIter; m1_bcIter = m1.begin(); m1_ecIter = m1.begin(); m1_ecIter++; m1_ecIter++; map m5(m1_bcIter, m1_ecIter); // Create a map m6 by copying the range m4[ first, last) // and with the allocator of map m2 map ::allocator_type m2_Alloc; m2_Alloc = m2.get_allocator(); map m6(m4.begin(), ++m4.begin(), less(), 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 ="; mapm7(move(m5)); for (auto i : m7) cout << i.first << " " << i.second << ", "; cout << endl; // Create a map m8 by copying in an initializer_list mapm8< < < 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 mapm9(< < 5, 5 >, < 6, 6 >, < 7, 7 >, < 8, 8 >>, less()); 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 mapm10(< < 9, 9 >, < 10, 10 >, < 11, 11 >, < 12, 12 >>, less(), m9.get_allocator()); cout
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 #include int main( ) < using namespace std; map m1; map :: size_type i; i = m1.max_size( ); cout
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 #include #include int main( ) < using namespace std; typedef pair cInt2Int; map m1; map :: 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 :: value_type ( 2, 20 ) ); m1.insert ( cInt2Int ( 3, 30 ) ); cout first; cout second; cout first; cout second; cout c2; string str("abc"); cout
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
Замечания
После удаления всех существующих элементов в map operator= копирует или перемещает содержимое right в сопоставление.
Пример
// map_operator_as.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; mapv1, v2, v3; map::iterator iter; v1.insert(pair(1, 10)); cout second second second
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 #include int main( ) < using namespace std; map m1; map :: iterator m1_Iter; map :: reverse_iterator m1_rIter; map :: const_reverse_iterator m1_crIter; typedef pair 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 first first first first ); m1_rIter = m1.rbegin( ); cout first
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 #include int main( ) < using namespace std; map m1; typedef pair 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 second ); cout 
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 #include int main( ) < using namespace std; map m1; map :: iterator m1_Iter; map :: reverse_iterator m1_rIter; map :: const_reverse_iterator m1_crIter; typedef pair 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 first first first first ); m1_rIter = m1.rend( ); m1_rIter--; cout first
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 reverse_iterator; 
Замечания
Тип reverse_iterator не может изменить значение элемента и используется для итерации по карте в обратном направлении.
Определяется reverse_iterator сопоставлением элементов, которые являются объектами value_type типа, pair чей первый член является ключом к элементу и чей второй член является сопоставленным 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 #include int main() < using namespace std; mapm1, m2; map::size_type i; typedef pair Int_Pair; m1.insert(Int_Pair(1, 1)); i = m1.size(); cout
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& right); 
Параметры
 right 
Сопоставление-аргумент предоставляет элементы для обмена с целевым сопоставлением.
Замечания
Функция-член не делает недействительными никакие ссылки, указатели или итераторы, обозначающие элементы в двух сопоставлениях, между которыми выполняется обмен элементами.
Пример
// map_swap.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map m1, m2, m3; map ::iterator m1_Iter; typedef pair 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 second; cout second; cout second; cout
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 карты, невозможно изменить его. Если возвращаемое значение назначено объекту iterator map, его можно изменить.
Пример
// map_upper_bound.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map m1; map :: const_iterator m1_AcIter, m1_RcIter; typedef pair 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 second 4 is: " second first ); cout << "The 1st element of m1 with a key greater than\n" << "that of the initial element of m1 is: " second
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) . Хранимый объект определяет функцию-член
возвращает true значение, если значение left ключа предшествует и не равно значению ключа right в порядке сортировки.
Пример
// map_value_comp.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; map > m1; map >::value_compare vc1 = m1.value_comp( ); pair< map::iterator, bool > pr1, pr2; pr1= m1.insert ( map :: value_type ( 1, 10 ) ); pr2= m1.insert ( map :: value_type ( 2, 5 ) ); if( vc1( *pr1.first, *pr2.first ) == true ) < cout else < cout if(vc1( *pr2.first, *pr1.first ) == true ) < cout else < cout > 
The element ( 1,10 ) precedes the element ( 2,5 ). The element ( 2,5 ) does not precede the element ( 1,10 ). 
value_type
Тип объекта, хранящегося в качестве элемента в сопоставлении.
typedef pair value_type; 
Пример
// map_value_type.cpp // compile with: /EHsc #include #include int main( ) < using namespace std; typedef pair cInt2Int; map m1; map :: key_type key1; map :: mapped_type mapped1; map :: value_type value1; map :: iterator pIter; // value_type can be used to pass the correct type // explicitly to avoid implicit type conversion m1.insert ( map :: 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 first; cout second; cout
Методы, обеспечивающие получение информации из контейнера
Методы begin() и end() позволяют получить итератор на начало и конец ассоциативного массива. Конец ассоциативного массива определяется как элемент, следующий за последним элементом массива. 
Общая форма объявления методов следующая:
iterator begin(); const iterator begin() const; iterator end(); const iterator end() const;
На рисунке 1 показан пример, в котором показаны позиции, возвращаемые методами begin() и end() .

Рисунок 1. Возврат результата методами begin() и end()
Пример.
В примере формируется ассоциативный контейнер, изображенный на рисунке 1. Затем с помощью методов begin() и end() определяются границы контейнера и происходит вывод контейнера на экран с помощью итератора.
#include iostream> #include map> using namespace std; void main() < // Методы begin() и end() // 1. Создать ассоциативный контейнер mapint, string> m1; m1.insert(pairint, string>(1, "Winter")); m1.insert(pairint, string>(2, "Spring")); m1.insert(pairint, string>(3, "Summer")); m1.insert(pairint, string>(4, "Autumn")); // 2. Получить итератор на начало и конец контейнера mapint, string>::iterator it, itEnd; it = m1.begin(); itEnd = m1.end(); // 3. Вывести содержимое контейнера на экран cout "m1:" while (it!=itEnd) < cout first " : " second >
m1: 1 : Winter 2 : Spring 3 : Summer 4 : Autumn
3. Метод count() . Получить количество дубликатов по ключу
Метод count() возвращает количество дубликатов элемента со значением ключа. Данный метод актуален для класса multimap , в котором одному ключу может соответствовать несколько значений. Общая форма объявления метода следующая:
inline size_t count(const keyType &keyVal) const;

keyType – тип ключа;
keyVal – значение ключа.

Пример.
#include iostream> #include map> using namespace std; void main() < // Метод count() - получить количество дубликатов по заданному ключу // 1. Сформировать ассоциативный массив mapchar, string> Colors; Colors.insert(make_pair('R', "Red")); Colors.insert(make_pair('G', "Green")); Colors.insert(make_pair('B', "Blue")); // 2. Попытка создать еще один дубликат ключа 'B' Colors.insert(make_pair('B', "Black")); // работает // 3. Вывести количество дубликатов для ключа 'B' cout 'B') // 1 // 4. Вывести количество дубликатов для ключа 'R' cout 'R') // 1 // 5. Попытка доступиться к несуществующему ключу try < cout 'F') // 0 > catch (out_of_range e) < cout >
1 1 0
4. Метод empty() . Определить, пуст ли массив
Метод empty() позволяет определить, есть ли в ассоциативном контейнере элементы. Спецификация метода имеет вид
inline bool empty() const;
Метод возвращает true , если в контейнере имеется хотя бы один элемент. Иначе метод возвращает false .
Пример.
#include iostream> #include map> using namespace std; void main() < // Метод empty() - определить, пуст ли массив // 1. Создать пустой контейнер mapint, char> m1; // 2. Вызвать функцию empty() if (m1.empty()) cout "m1 is empty" else cout "m1 is not empty" // 3. Прибавить к контейнеру несколько элементов m1.insert(make_pair(1, 'A')); m1.insert(make_pair(2, 'B')); m1.insert(make_pair(3, 'C')); // 4. Повторно вызвать empty() if (m1.empty()) cout "m1 is empty" else cout "m1 is not empty"
m1 is empty m1 is not empty
5. Метод find() . Получить итератор на заданный ключ
Метод find() возвращает итератор, установленный на заданный ключ. Синтаксис объявления наиболее распространенных реализаций метода имеет вид:
inline iterator find(const keyType &keyVal) const; inline iterator find(const keyType &keyVal);

keyType – тип ключа;
keyVal – значение ключа.

Пример.
#include iostream> #include map> using namespace std; void main() < // Метод find() - найти элемент по ключу // 1. Сформировать ассоциативный массив mapbool, string> m1; m1.insert(make_pair(true, "True")); m1.insert(make_pair(false, "False")); // 2. Найти ключ true и вывести его mapbool, string>::iterator it; it = m1.find(true); cout first " : " second // 3. Найти ключ false и вывести его it = m1.find(false); cout first " : " second
1 : True 0 : False
6. Метод max_size() . Максимальный размер контейнера
Метод max_size() возвращает максимальное количество элементов в контейнере. Это количество зависит от типа ключа и значения в паре, размера свободной памяти и т.д.
Синтаксис объявления метода
inline size_t max_size() const;
Пример.
#include iostream> #include map> using namespace std; void main() < // Метод max_size() - получить максимально возможный размер контейнера // 1. Объявить пустой контейнер mapstring, string> code; // 2. Прибавить к контейнеру элемент code.insert(make_pair("USA", "1")); // 3. Вывести max_size() cout // 164703072086692425 // 4. Прибавить еще элемент code.insert(make_pair("Ukraine", "380")); // 5. Вывести max_size() cout // 164703072086692425 >
164703072086692425 164703072086692425
7. Метод size() . Получить текущее количество элементов в массиве
Метод size() возвращает количество элементов в ассоциативном контейнере. При создании пустого контейнера метод вернет 0.
Синтаксис объявления метода
inline size_t size() const;
Пример.
#include iostream> #include map> using namespace std; void main() < // Метод size() - получить размер контейнера // 1. Объявить пустой контейнер mapstring, string> code; // 2. Получить размер контейнера int size = code.size(); cout // 0 // 3. Прибавить к контейнеру элемент code.insert(make_pair("USA", "1")); // 4. Вывести size() cout // 1 // 5. Прибавить еще элемент code.insert(make_pair("Ukraine", "380")); // 6. Вывести size() cout // 2 >
0 1 2
8. Операторная функция operator[]() . Получить значение по заданному ключу
С помощью операторной функции operator[]() можно обращаться к значениям массива по его ключам естественным способом с помощью квадратных скобок [] . Синтаксис объявления функции в классе map следующий
inline vType& mapkType, vType>::operator[](kType &&_KeyVal);

kType – тип ключа;
vType – тип значения;
_KeyVal – значение ключа.

Метод может использоваться как в выражении, так и в левой части оператора присваивания = . 
Если ключ _KeyVal отсутствует в контейнере, и операция [] используется в левой части оператора присваивания, создается ключ с соответствующим значением.
Пример.
#include iostream> #include map> using namespace std; void main() < // Операторная функция operator[] - переопределение оператора [] // 1. Создать контейнер через список инициализации initializer_listpairconst string, int>> lst = < make_pair("Jan", 31), make_pair("Feb", 28), make_pair("Mar", 31), make_pair("Apr", 30), make_pair("May", 31), make_pair("Jun", 30), make_pair("Jul", 31), make_pair("Aug", 31), make_pair("Sep", 30), make_pair("Oct", 31), make_pair("Nov", 30), make_pair("Dec", 31) >; mapstring, int> m1; m1.insert(lst); // 2. Получить количество дней в марте int d = m1["Mar"]; cout "d color: #008000;"> // 3. Изменить количество дней в феврале m1["Feb"] = 29; // 4. Проверка, изменено ли количество дней в феврале d = m1["Feb"]; // d = 29 cout "d color: #008000;"> // 5. Создать новую пару "ABCD":333 m1["ABCD"] = 333; // 6. Вывести массив mapstring, int>::iterator it = m1.begin(); cout "m1:" while (it != m1.end()) < cout first ":" second >
d = 31 d = 29 m1: ABCD:333 Apr:30 Aug:31 Dec:31 Feb:29 Jan:31 Jul:31 Jun:30 Mar:31 May:31 Nov:30 Oct:31 Sep:30
Связанные темы

Создание контейнера. Конструкторы. Создание пары. Обзор функций и операторов класса
Методы, изменяющие данные в контейнере: clear() , erase() , insert() , swap() , operator=()



Похожие публикации:

Change configuration settings pycharm что делать
Как написать уравнение по графику
Как считать число из файла c
Почему эксель меняет цифры на другие