Вы находитесь на странице: 1из 15

Контейнер map, очень похож на остальные контейнеры, такие как vector, list, deque, но с

небольшим отличием. В этот контейнер можно помещать сразу два значения. Если у Вас
когда-то была мечта написать свой словарь, то лучше чем map, вам альтернативы не найти. И
так, что же такое этот map, давай рассмотрим более подробнее на примере:
#include <iostream>
#include <map> //подключили библиотеку для работы с map
using namespace std;

int main()
{
map <string,int> myFirstMap = {{ "Mother", 37 },
{ "Father", 40 },
{ "Brother", 15 },
{ "Sister", 20 }};

///вывод явно инициализированной map на экран


for (auto it = myFirstMap.begin(); it != myFirstMap.end(); +
+it)
{
cout << it->first << " : " << it->second << endl;
}

char c;
map <char,int> mySecondMap;
for (int i = 0,c = 'a'; i < 5; ++i,++c)
{
mySecondMap.insert ( pair<char,int>(c,i) );
}

///вывод не явно инициализированной map на экран


for (auto it = mySecondMap.begin(); it != mySecondMap.end(); +
+it)
{
cout << (*it).first << " : " << (*it).second << endl;
}
return 0;
}
Пример выполнения программы:
CppStudio.com
Brother : 15
Father : 40
Mother : 37
Sister : 20
a:0
b:1
c:2
d:3
e:4
Во 2 строке мы подключили библиотеку для работы с map. В строках 7-10 происходит явное
объявление map, это объявление ничем не отличается от объявления векторов, массивов, за
исключением того, что объявляются сразу два типа переменных (первый тип – string,
второй тип — int). В кавычках объявляются строки, а через запятую соответствующее
строке число. Если бы написали вместо string тип char, то объявление было-бы таким:

1 map <char,int> myFirstMap= {{ 'm', 37 },


2 { 'f', 40 },
3 { 'b', 15 },
4 { 's', 20 }};

Нужно добавить, что map можно использовать в виде ассоциативного массива. Массива
который позволяет в себе хранить пару вида («ключ», «значение»), а так-же добавлять и
удалять пары по ключу. У нас в роли ключа выступает тип string, а в роли значения тип
int.

Осуществление вывода ничем не отличается от вывода тех же векторов. Обратите внимание,


что вывод осуществляется в алфавитном порядке, а заполнение map в строках 7-10, нет.
Контейнер map сам выполняет сортировку по алфавиту. В строках 13-16 осуществляется
вывод с помощью итератора it. Итератор it сначала указывает на начало map и с каждой
новой итерацией увеличивается, пока не достигнет конца map. Самое интересное
располагается в строке 15. Запись вида it->first означает, что it при первой итерации
указывает на строку Mother, потом на Father и так далее до конца цикла, соответственно,
запись вида it->second означает, что it при первой итерации указывает на число 37,
потом на 40 и так далее.
В строке 19 мы объявили map mySecondMap. В строках 20-23 заполняем его. Строка
22 содержит функцию map::insert(). Которая вставляет элементы в map. Запись
вида pair<char,int>(c,i) означает, что в map помещаются две переменные типа
char и int (первая – char, вторая — int), где типу char соответствует переменная c, а
типу int соответствует переменная i. В строке 20 при каждой новой итерации наши
переменные будут увеличиваться, т. е. сначала i=0, c=a, при следующей итерации i=1,
c=b и т. д. В строке 28 показан альтернативный вывод map с помощью указателей. У map
есть один небольшой недостаток, она не может содержать два одинаковых значения, но
multimap решает эту проблему, пример:
#include <iostream>
#include <map>
using namespace std;

int main()
{
map <char,int> myFirstMap;///объявили map

///заполняем myFirstMap
myFirstMap.insert ( pair<char,int>('a',10) );
myFirstMap.insert ( pair<char,int>('a',20) );
myFirstMap.insert ( pair<char,int>('a',10) );

cout << "myFirstMap contains:\n";


for (auto it = myFirstMap.begin(); it != myFirstMap.end(); +
+it)///вывод на экран
{
cout << it->first << " : " << it->second << endl;
}
multimap <char,int> myFirstMultimap;///объявили multimap

///заполняем myFirstMultimap
myFirstMultimap.insert ( pair<char,int>('a',10) );
myFirstMultimap.insert ( pair<char,int>('a',20) );
myFirstMultimap.insert ( pair<char,int>('a',10) );

cout << "myFirstMultimap contains:\n";


for (auto it = myFirstMultimap.begin(); it !=
myFirstMultimap.end(); ++it)///вывод на экран
{
cout << it->first << " : "<< it->second << endl;
}
return 0;
}
Пример выполнения программы:
CppStudio.com
myFirstMap contains:
a : 10
myFirstMultimap contains:
a : 10
a : 20
a : 10
Работа программы должна быть полностью понятна, так, что на ней останавливаться не
будем. Как видите контейнер myFirstMap может содержать только одно не повторяющееся
значение <char, int>, а multimap нет. С этой целью и был создан контейнер multimap.
Multimap ничем не отличается от map, за исключением того, что в нем можно хранить
повторяющиеся элементы.
Контейнер map (функции at(), clear(), count(), erase(), empty())
При помощи функции map::at(), зная «ключ», всегда можно изменить «значение» map.
Пример:
#include <iostream>
#include <map>
using namespace std;
int main()
{
map <string,int> myMap = {{ "Beta", 2 }, ///явная инициализация
map
{ "Alpha", 1 },
{ "Gamma", 3 }};

///присвоение элементам map новых значений


myMap.at("Beta") = 0;
myMap.at("Alpha") = 233;
myMap.at("Gamma") = -45;

cout << "myMap contains:\n";


for(auto it = myMap.begin(); it != myMap.end(); ++it)
{
cout << it->first << " : " << it->second << endl;///вывод
на экран
}

multimap <char,int> myMultimap;///объявили multimap

///заполняем myMultimap
myMultimap.insert ( pair<char,int>('q',111) );
myMultimap.insert ( pair<char,int>('u',201) );
myMultimap.insert ( pair<char,int>('h',301) );

cout << "\nmyMultimap contains:\n";


for (auto it = myMultimap.begin(); it != myMultimap.end(); +
+it)
{
cout << it->first << " : " << it->second << endl;
}

myMap.clear();
myMultimap.clear();

///новая инициализация myMap


myMap = {{ "Mike", 40 },
{ "Walle", 999 },
{ "Cloude", 17 }};

///новая инициализация myMultimap


myMultimap.insert ( pair<char,int>('q',222) );
myMultimap.insert ( pair<char,int>('u',223) );
myMultimap.insert ( pair<char,int>('h',221) );
auto itMap = myMap.begin();///создаем итератор на начало myМap
auto itMultimap = myMultimap.begin();///создаем итератор на
начало myMultimap
cout << "\nmyMap after clear contains: \t myMultimap after
clear contains:\n";

///вывод на экран myMap и myMultimap


for(itMap = myMap.begin(),itMultimap = myMultimap.begin();
itMultimap != myMultimap.end(); itMap++,itMultimap++)
{
cout << "\t" <<itMap->first << " : " << itMap->second <<
"\t\t\t\t" << itMultimap->first << " : " << itMultimap->second <<
endl;
}
return 0;
}
Выполнение программы:
CppStudio.com
myMap contains:
Alpha : 233
Beta : 0
Gamma : -45
myMultimap contains:
a : 301
b : 111
c : 201
myMap after clear contains:
myMultimap after clear contains:
Cloude : 17 h : 221
Mike : 40 q : 222
Vally : 999 u : 223
В строках 7 по 9 происходит явная инициализация контейнера map. Т. к. каждому «ключу»
соответствует единственное «значение», то в строках 12-14 при помощи функции
map::at(), используя «ключ», мы изменяем установленное «значение». Вывод
осуществляемый в строках 17-20, наглядно демонстрирует это. Multimap не поддерживает
функцию map::at().

В 22 строке объявили контейнер multumap, который принимает два типа переменных char
и int. В строках 25-27 производим заполнение контейнера multimap, а в строках 30-33
осуществляем вывод. В строке 35, 36 при помощи функции map::clear(), производится
очистка контейнера multimap и map. В строках 39-41 и 44-46 производится заполнение
контейнеров multimap и map новыми значениями. В строке 48, 49 создается итератор
itMap указывающий на начало myMap и итератор itMultimap, указывающий на начало
myMultimap. В строках 53-56 соответственно производится вывод map и multimap с
новыми значениями.
Контейнеры multimap и map содержат функцию которая позволяет выполнять поиск
заданного элемента по контейнеру, пример:

#include <iostream>
#include <map>
using namespace std;

int main()
{
multimap <char,int> myMultimap;
map <char,int> myMap;
char c;
for (int i = 0,c = 'a'; i < 5; ++i,++c)
{
myMap[c] = i;///заполняем map
}

///заполняем multimap
myMultimap.insert ( pair<char,int>('c',146) );
myMultimap.insert ( pair<char,int>('a',23) );
myMultimap.insert ( pair<char,int>('b',996) );
myMultimap.insert ( pair<char,int>('a',56) );
myMultimap.insert ( pair<char,int>('c',121) );
auto itMap = myMap.begin();///создаем итератор на начало myМap
auto itMultimap = myMultimap.begin();///создаем итератор на
начало myMultimap
cout<<"myMap contains: \t myMultimap contains:\n";

///вывод на экран myMap и myMultimap


for(itMap = myMap.begin(),itMultimap = myMultimap.begin();
itMultimap != myMultimap.end(); itMap++,itMultimap++)
{
cout << itMap->first << " : " << itMap->second <<
"\t\t\t\t" << itMultimap->first << " : " << itMultimap->second <<
endl;
}

for(c = 'a'; c <= 'f'; c++)


{
myMap.count(c) ? cout << "\nNumber of elements '" << c <<
"' in myMap = " << myMap.count(c) : cout << "\nElement '" << c <<
"' is not in myMap ";
myMultimap.count(c) ? cout << "\nNumber of elements '" << c
<< "' in myMultimap " << myMultimap.count(c) : cout << "\nElement
'" << c << "' is not in myMultimap";
}

itMap = myMap.find('b');///итератор на заданный элемент в map


itMultimap = myMultimap.find('a');///итератор на заданный
элемент в multimap
myMap.erase(itMap);///стираем его в map
myMultimap.erase(itMultimap);///стираем его в multimap
itMap = myMap.find('d');
itMultimap = myMultimap.find('d');
myMap.erase(itMap,myMap.end());///стираем c элемента 'd' и до
конца map
myMultimap.erase(itMultimap,myMultimap.end());///стираем c
элемента 'd' и до конца multimap

cout << "\n\nmyMap contains: \t myMultimap contains:\n";


for(itMap = myMap.begin(),itMultimap = myMultimap.begin();
itMap != myMap.end(); itMap++,itMultimap++)
{
cout << itMap->first << " : " << itMap->second <<
"\t\t\t\t" << itMultimap->first << " : " << itMultimap->second <<
endl;///вывод на экран
}

myMap.clear();
myMap.empty() ? cout << "\nmyMap is empty\n" : cout << "myMap
isn't empty\n";
myMultimap.empty() ? cout << "\nmyMultimap is empty\n" : cout
<< "myMultimap isn't empty\n";

return 0;
}
Выполнение программы:
CppStudio.com
myMap contains: myMultimap contains:
a:0 a : 23
b:1 a : 56
c:2 b : 996
d:3 c : 146
e:4 c : 121
Number of elements ‘a’ in myMap = 1
Number of elements ‘a’ in myMultimap 2
Number of elements ‘b’ in myMap = 1
Number of elements ‘b’ in myMultimap 1
Number of elements ‘c’ in myMap = 1
Number of elements ‘c’ in myMultimap 2
Number of elements ‘d’ in myMap = 1
Element ‘d’ is not in myMultimap
Number of elements ‘e’ in myMap = 1
Element ‘e’ is not in myMultimap
Element ‘f’ is not in myMap
Element ‘f’ is not in myMultimap
myMap contains: myMultimap contains:
a:0 a : 56
c:2 b : 996
myMap is empty
myMultimap isn’t empty
Думаю, до строки 31, код должен быть понятен, если нет, то в двух словах происходит
следующее: мы объявляем контейнер multimap и map, заполняем и выводим их. В 33 и 34
строке используется функция map::count(), которая осуществляет подсчет элементов в
контейнерах multimap и map по заданному «ключу». Если такой ключ есть то будет
выведено количество «ключей» в map и multimap иначе, будет выведено сообщение, что
таких ключей нет В строках 33 и 34 применяется тернарный оператор.
Функция map::find() осуществляет поиск в контейнере заданного «ключа». Функция
принимает один аргумент («ключ» который требуется найти в контейнере map или
multimap). В 37 строке создается итератор itMap указывающий на «ключ» b в контейнере
map. В 38 строке создается итератор itMultimap, указывающий на «ключ» а,но уже в
контейнере multimap.

В строке 39 встречается функция map::erase(). Работа этой функции не чем не


отличается от работы функции vector::erase(). Функция может принимать один или
два аргумента. При принятии одного аргумента из контейнера map или multimap удаляется
заданный аргумент, если аргументов двое, то первый аргумент указывает на место откуда
начнется удаление, второй по куда будет произведено удаление аргументов. Поскольку
итератор itMap указывает на b, а itMultimap указывает на а, то соответственно в 39
строке из контейнера map будет удалено b, а в строке 40 из multimap удалено а. В строке
41 мы говорим итератору itMap, чтобы он указывал на d в контейнере map, соответственно
в 42 строке итератор itMultimap начинает указывать тоже на d, но в контейнере
multimap. В строке 43 мы очищаем контейнер map начиная с d и до конца map. Тоже
происходит в строке 44, но уже с контейнером multimap. В строках 47-49 производится
вывод на экран содержимых контейнеров multimap и map после удаления из них
элементов.
Функция map::clear() используемая в строке 52 полностью очищает контейнер map.
Функцию map::clear() поддерживает и контейнер multumap. Я специально очистил
только один контейнер map, что бы на примере функции map::empty() (описанной в 53 и
54 строке) показать, что контейнер действительно пуст. Думаю, работа кода в строках 53 и
54 должна быть понятна.

Контейнер map: функции insert(), emplace(),


lower_bound(), upper_bound()
Поскольку, Вы уже сталкивались с функцией map::insert(), в следующем примере, я
покажу, альтернативные варианты добавления элементов в контейнер multimap и map,
например:

#include <iostream>
#include <map>

using namespace std;


int main ()
{
multimap<float,string> myMultimapExample;
map<string,float> myMapExample;

/// первый вариант


myMapExample.insert ( pair<string,float>("Desk",0.01) );
myMapExample.insert ( pair<string,float>("Table",0.02) );
myMultimapExample.insert ( pair<float,string>(0.01,"Desk") );
myMultimapExample.insert ( pair<float,string>(0.01,"Table") );

/// второй вариант


multimap<float,string>::iterator itMultimapExample =
myMultimapExample.begin();///итератор указывает на начало
multimap
map<string,float>::iterator itMapExample =
myMapExample.begin();
myMapExample.insert ( itMapExample,
pair<string,float>("Pencil",0.03) );
myMultimapExample.insert ( itMultimapExample,
pair<float,string>(0.03,"Pencil") );

/// третий вариант


map<string,float> myMapExampleDifferent;
multimap<float,string> myMultimapExampleDifferent;
myMapExampleDifferent.insert( myMapExample.begin(),myMapExample
.find("Table") );
myMultimapExampleDifferent.insert( myMultimapExample.begin(),my
MultimapExample.find(0.03) );
/// вывод на экран map и multimap:
cout << "myMapExample: \t\t myMultimapExample:\n";
for ( itMapExample = myMapExample.begin(),itMultimapExample =
myMultimapExample.begin(); itMapExample != myMapExample.end(); +
+itMapExample,++itMultimapExample)
{
cout << itMapExample->first << " : " << itMapExample-
>second << "\t\t " << itMultimapExample->first << " : " <<
itMultimapExample->second << endl;
}

auto itMapExampleDif = myMapExampleDifferent.begin();


auto itMultimapExampleDif = myMultimapExampleDifferent.begin();
cout << "\nmyMapExampleDifferent: \t
myMultimapExampleDifferent:\n";
for ( itMapExampleDif,itMultimapExampleDif; itMapExampleDif !=
myMapExampleDifferent.end(); ++itMapExampleDif,+
+itMultimapExampleDif)
{
cout << itMapExampleDif->first << " : " << itMapExampleDif-
>second << "\t\t " << itMultimapExampleDif->first << " : " <<
itMultimapExampleDif->second << '\n';
}

return 0;
}
Работа программы:
CppStudio.com
myMapExample: myMultimapExample:
Desk : 0.01 0.01 : Desk
Pencil : 0.03 0.01 : Table
Table : 0.02 0.03 : Pencil
myMapExampleDifferent: myMultimapExampleDifferent:
Desk : 0.01 0.01 : Desk
Pencil : 0.03 0.01 : Table
• Вариант №1 — или самый распространенный вариант. В строке 11 и 12 с помощью
функции map:: insert(), мы добавляем элементы в map. Функция принимает два
аргумента, первый аргумент ключ, у нас это тип string, второй это значение, у
нас это тип float. Строки 13 и 14 идентичны строками 11 и 12, но там элементы
добавляются в multimap.
• Вариант №2 — с использованием итератора. В строке 17 создаем
итераторitMultimapExample, в строке 18, итератор itMapExample.
Функцииmap::insert(), в строке 19 мы передаем два аргумента (первым
аргументом выступает наш итератор itMapExample, а вторым, пара
ключ, значение). Строка 20 равносильна строке 19, только там
функция map::insert(), применяется к контейнеру multimap. Может возникнуть
вопрос, чем первый вариант отличается от второго? Ответ, тем, что нашим итератором
мы рекомендуем позицию, с которой следует начинать поиск позиции элемента,
который мы хотим вставить.
• Вариант №3 — с использованием функции map::find(). В строке 23, 24 объявляем еще
один контейнер map и multimap. Строку 25 можно прочитать так: заполняй
контейнер myMapExampleDifferent, начиная с начала myMapExample, пока в
контейнере myMapExample не встретишь ключ Table. Этот ключ не будет вставлен
в myMapExample. Строка 26 выполняет предыдущее действие, но применительно к
multimap контейнеру. Вывод на экран myMapExample и myMultimapExample
осуществляется в строках 30-33, а вывод
myMapExampleDifferent и myMultimapExampleDifferent строках 38-41 .

Multimap кроме функции map::insert(), поддерживает еще функцию


map::emplace(), рассмотрим пример:
#include <iostream>
#include <map>

using namespace std;


int main ()
{
multimap<char,float> mymultimap;
map<char,float> mymap;

///заполняем multimap
mymultimap.insert( pair<char,float>('a',0.1) );
mymultimap.insert( pair<char,float>('b',0.2) );
mymultimap.insert( pair<char,float>('d',0.4) );
mymultimap.insert( pair<char,float>('e',0.5) );

///заполняем map
mymap.insert( pair<char,float>('f',5.3) );
mymap.insert( pair<char,float>('g',4.32) );
mymap.insert( pair<char,float>('i',23.41) );
mymap.insert( pair<char,float>('r',6.5) );

///вставляем элементы в multimap


mymultimap.emplace('c',0.3);
mymultimap.emplace('b',9.9);
cout << "mymultimap have:" << endl;
for (auto it = mymultimap.begin(); it != mymultimap.end(); +
+it)
{
cout << it->first << " : " << it->second << endl;
}

auto lowerMap=mymap.lower_bound('g');/// нижняя граница map


auto upperMap=mymap.upper_bound('i');///верхняя граница map
auto lowerMultimap=mymultimap.lower_bound('b');/// нижняя
граница multimap
auto upperMultimap=mymultimap.upper_bound('d');///верхняя
граница multimap

mymultimap.erase(lowerMultimap,upperMultimap);
mymap.erase(lowerMap,upperMap);
auto itMultimap = mymultimap.begin();
auto itMap = mymap.begin();
cout << "\nmymultimap have: \t mymap have:" << endl;
for (itMultimap,itMap; itMultimap != mymultimap.end(); +
+itMultimap,++itMap)
{
cout << itMultimap->first << " : " << itMultimap->second <<
"\t\t " << itMap->first << " : " << itMap->second << endl;
}
return 0;
}
Работа программы:
CppStudio.com
mymultimap have:
a : 0.1
b : 0.2
b : 9.9
c : 0.3
d : 0.4
e : 0.5
mymultimap have: mymap have:
a : 0.1 f : 5.3
e : 0.5 r : 6.5
В строках 11-14 происходит заполнение контейнера multimap, в строках 17-20 происходит
заполнение контейнера map. В строке 23 встречается функция map::emplace(), которая
равносильна функции map::insert, но ей не нужно, явно, каждый раз, указывать тип
переменной. В строках 26-29 осуществляет вывод на экран контейнера multimap.
Контейнер map не поддерживает функцию map::emplace(). В строке 31 мы встречаем
функцию map::lower_bound(). Эта функция принимает только один аргумент и
возвращает первую позицию в которую может быть вставлен этот элемент. С помощью
функции map::lower_bound(), создаем итератор, указывающий на ключ g в контейнере
map. В 32 строке мы встречаем функцию map::upper_bound(), она возвращает
последнюю позицию , в которую может быть вставлен элемент. В строке 32 создаем еще
один итератор, но уже с помощью функции map::upper_bound() и указывающий
на ключ i. В строках 33, 34, выполняется тоже, но с контейнером multimap. Данные
итераторы выступают в роли «границ», где при помощи map::erase() в строке 38, 39,
мы очищаем оба контейнера (границы контейнеров, тоже стираются). Что осталось в
контейнерах, показано в строках 43-46, где осуществляется вывод на экран.
Обмен содержимым контейнеров map и
multimap
Для того, что бы поменять содержимое контейнеров местами, можно использовать
следующий код:
map<char,int> MapFirst,MapSecond,temp;

temp=MapFirst;
MapFirst=MapSecond;
MapSecond=temp;
Но в С++ предусмотрена для этого специальная функция map::swap(), которая позволяет
менять содержимое контейнеров map и multimap местами, сейчас покажу как.
#include <iostream>
#include <map>

using namespace std;


int main ()
{
map<char,int> MapFirst;
map<char,int> MapSecond;

MapFirst['a']=1;
MapFirst['b']=2;

MapSecond['z']=23;
MapSecond['y']=22;

cout << "MapFirst keeps before swap: MapSecond keeps before


swap:" << endl;
auto itMapFirst=MapFirst.begin();
auto itMapSecond=MapSecond.begin();
for(itMapFirst,itMapSecond; itMapFirst != MapFirst.end(); +
+itMapFirst,++itMapSecond)
{
cout << itMapFirst->first << " : " << itMapFirst->second <<
"\t\t\t\t\t"
<< itMapSecond->first << " : " << itMapSecond->second
<<endl;
}

swap(MapFirst,MapSecond);///обмен

cout << "MapFirst keeps after swap: MapSecond keeps after


swap:" << endl;
itMapFirst=MapFirst.begin();
itMapSecond=MapSecond.begin();
for(itMapFirst,itMapSecond; itMapFirst != MapFirst.end(); +
+itMapFirst,++itMapSecond)
{
cout << itMapFirst->first << " : " << itMapFirst->second <<
"\t\t\t\t\t"
<< itMapSecond->first << " : " << itMapSecond->second
<<endl;
}

MapFirst.swap(MapSecond);///обмен

cout << "MapFirst keeps after anoter swap: MapSecond keeps


after anoter swap:" << endl;
itMapFirst=MapFirst.begin();
itMapSecond=MapSecond.begin();
for(itMapFirst,itMapSecond; itMapFirst != MapFirst.end(); +
+itMapFirst,++itMapSecond)
{
cout << itMapFirst->first << " : " << itMapFirst->second <<
"\t\t\t\t\t"
<< itMapSecond->first << " : " << itMapSecond->second
<<endl;
}

return 0;
}

Вывод программы:
CppStudio.com
MapFirst keeps before swap: MapSecond keeps before swap:
a:1 y : 22
b:2 z : 23
MapFirst keeps after swap: MapSecond keeps after swap:
y : 22 a:1
z : 23 b:2
MapFirst keeps after anoter swap: MapSecond keeps after anoter swap:
a:1 y : 22
b:2 z : 23
В строках 10, 11 мы заполняем контейнер MapFirst, в строках 13,14 контейнер
MapSecond.

Обратите внимание на еще один вариант заполнения контейнера map. В квадратных скобках
мы указываем наш ключ, а после знака равенства — значение.

В строках 19-23, выводим на экран содержимое наших контейнеров. В строке 25 происходит


смена элементов двух контейнеров. Теперь контейнер MapFirst содержит то, что содержал
контейнер MapSecond, а MapSecond содержит значения контейнера MapFirst.

Важно: функция map::swap() работает только в случае, если контейнеры относятся к


одному типу т. е., если вы напишите, что-то вроде этого:
1 map<char,int> MapFirst;
2 map<char,float> MapSecond;
компилятор выдаст ошибку. Будьте внимательны, не допускайте подобного.
В строках 30-34 осуществляется вывод на экран. Альтернативный вариант функции
map::swap() показан в строке 36 и вывод в строках 41-45 показывающий, что функция
отработала верно. Для контейнера multimap все работает так же, как и для контейнера map.

Object 1