Класс map. Методы изменяющие данные в контейнере

Содержание

Поиск на других ресурсах:

1. Метод clear(). Очистить ассоциативный массив

Метод clear() удаляет из ассоциативного массива все элементы. Синтаксис объявления метода

void clear();

Пример.

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

void main()
{
  // Метод clear() - очистить массив
  // 1. Сформировать ассоциативный массив
  map<string, int> Days;
  Days.insert(make_pair("January", 31));
  Days.insert(make_pair("February", 28));
  Days.insert(make_pair("March", 31));
  Days.insert(make_pair("April", 30));

  // 2. Вывести размер массива
  cout << Days.size() << endl;

  // 3. Очистить массив - метод clear()
  Days.clear();

  // 4. Повторно вывести размер массива
  cout << Days.size() << endl;
}

Результат

4
0

⇑

2. Метод erase(). Удалить элемент из ассоциативного контейнера

Метод erase() удаляет элемент или группу элементов разными способами. Метод имеет несколько перегруженных реализаций.

2.1. Удаление одного элемента по заданному ключу

Распространенной реализацией метода erase() является удаление элемента на основе заданного ключа. Синтаксис объявления этой реализации следующий

inline size_t erase(const keyType &keyVal);

здесь

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

Пример.

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

void main()
{
  // Метод erase() - удалить один элемент по ключу
  // 1. Сформировать ассоциативный массив
  map<char, string> m1;
  m1.insert(make_pair('A', "Assembler"));
  m1.insert(make_pair('B', "Bash"));
  m1.insert(make_pair('C', "C++"));
  m1.insert(make_pair('D', "Dart"));
  m1.insert(make_pair('E', "Erlang"));
  m1.insert(make_pair('F', "Fortran"));

  // 2. Удалить элементы 'A' и 'D'
  m1.erase('A');
  m1.erase('D');

  // 3. Вывести измененный массив
  map<char, string>::iterator it = m1.begin();
  cout << "m1: " << endl;
  while (it != m1.end())
  {
    cout << it->first << " : " << it->second << endl;
    it++;
  }
}

Результат

m1:
B : Bash
C : C++
E : Erlang
F : Fortran

⇑

2.2. Удаление одного элемента, на который указывает итератор

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

inline iterator erase(const_iterator Where);

здесь

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

Пример.

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

void main()
{
  // Метод erase() - удалить один элемент на основе ключа
  // 1. Сформировать ассоциативный массив
  map<char, string> m1;
  m1.insert(make_pair('A', "Assembler"));
  m1.insert(make_pair('B', "Bash"));
  m1.insert(make_pair('C', "C++"));
  m1.insert(make_pair('D', "Dart"));
  m1.insert(make_pair('E', "Erlang"));
  m1.insert(make_pair('F', "Fortran"));

  // 2. Установить итератор на пару 'F':"Fortran"
  map<char, string>::iterator it = m1.find('F');

  // 3. Удалить пару
  m1.erase(it);

  // 4. Вывести массив
  cout << "m1:" << endl;
  it = m1.begin();
  while (it != m1.end())
  {
    cout << it->first << " : " << it->second << endl;
    it++;
  }
}

Результат

m1:
A : Assembler
B : Bash
C : C++
D : Dart
E : Erlang

⇑

2.3. Удаление нескольких элементов, которые заданы диапазоном

Диапазон определяется итератором начала и итератором конца

inline iterator erase(const_iterator First, const_iterator Last);

здесь

iterator, const_iterator – тип итератора и константного итератора для текущего контейнера;
First – элемент, определяющий начало диапазона удаления;
Last – элемент, определяющий конец диапазона удаления. Значение Last указывает на элемент, находящийся за последним удаляемым элементом.

Пример.

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

void main()
{
  // Метод erase() - удалить диапазон элементов
  // 1. Сформировать ассоциативный массив
  map<int, char> m1;
  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'));

  // 2. Вывести массив - тупо, но работает
  cout << "m1: " << endl;
  for (int i = 0; i < m1.size(); i++)
    cout << i + 1 << " : " << m1[i + 1] << endl;

  // 3. Удалить элементы 2, 3 - литеры 'B', 'C'
  // 3.1. Объявить итераторы
  map<int, char>::iterator itFirst;
  map<int, char>::iterator itLast;

  // 3.2. Установить итераторы на позиции 2, 3
  itFirst = m1.find(2); // установить на ключ 2
  itLast = m1.find(4); // установить на ключ 4, который следует за ключом 3

  // 3.3. Метод erase - удалить диапазон
  m1.erase(itFirst, itLast);

  // 4. Повторно вывести массив с помощью итератора
  // 4.1. Объявить дополнительный итератор
  map<int, char>::iterator it = m1.begin();

  // 4.2. Непосредственный вывод массива
  cout << "------------------" << endl;
  cout << "m1: " << endl;
  while (it != m1.end())
  {
    cout << it->first << " : " << (*it).second << endl;
    it++;
  }
}

Результат

m1:
1 : A
2 : B
3 : C
4 : D
5 : E
------------------
m1:
1 : A
4 : D
5 : E

⇑

3. Метод insert(). Добавить новую пару в массив

Метод insert() добавляет в ассоциативный контейнер новую пару. Метод имеет много перегруженных реализаций. Ниже приведены некоторые из этих реализаций.

3.1. Вставить элементы на основе списка инициализации std::initializer_list

С помощью данной реализации метода insert() сначала создается список инициализации типа std::initializer_list, затем этот перечень передается аргументом в метод insert(). Объявление метода имеет вид

inline void insert(initializer_list<pair<const kType, vType>> _llist);

здесь

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

Приклад.

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

void main()
{
  // Метод insert() - вставить элемент.
  // Сформировать ассоциативный массив на основе списка инициализации
  // 1. Создать список инициализации
  initializer_list <pair<const int, string>> ls = {
    make_pair(1, "One"),
    make_pair(2, "Two"),
    make_pair(3, "Three")
  };

  // 2. Создать ассоциативный контейнер
  map<int, string> m1;

  // 3. Вставить список инициализации в массив
  m1.insert(ls);

  // 4. Вывести массив
  map<int, string>::iterator it = m1.begin(); // объявить итератор
  cout << "m1" << endl;
  while (it != m1.end())
  {
    cout << it->first << " : " << it->second << endl;
    it++;
  }
}

Результат

m1
1 : One
2 : Two
3 : Three

⇑

3.2. Добавить пару в контейнер

Чтобы добавить пару key:value в контейнер, используется следующая реализация метода insert()

inline iterator insert(pair<kType, vType> &_Val);

здесь

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

Пример.

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

void main()
{
  // Метод insert() - вставить пару в контейнер
  // 1. Объявить пустой контейнер строк
  map<string, long int> population;

  // 2. Вставить пару - методы insert() + make_pair()
  population.insert(make_pair("China", 1.402E9L));

  // 3. Вставить пару - использовать объект типа pair
  pair<string, long int> p("India", 1.38E9L);
  population.insert(p);

  // 4. Вставить пару - использовать конструктор типа pair
  population.insert(pair<string, long int>("USA", 328E6L));
  population.insert(pair<string, long int>("Ukraine", 52E6L));

  // 5. Вывести новосозданный контейнер
  map<string, long int>::iterator it = population.begin();
  cout << "population:" << endl;
  while (it != population.end())
  {
    cout << it->first << " : " << it->second << endl;
    it++;
  }
}

Результат

population:
China : 1402000000
India : 1380000000
USA : 328000000
Ukraine : 52000000

Данная реализация метода insert() позволяет вставлять целый диапазон пар key:value из ранее сформировавшегося ассоциативного массива. Диапазон задается двумя итераторами. Первый итератор указывает начало диапазона. Второй итератор указывает на элемент, находящийся за последним элементом диапазона, который нужно вставить.

Синтаксис объявления метода

inline void insert(_Iter First, _Iter Last);

здесь

_Iter – тип итератора;
First, Last – итераторы, определяющие диапазон элементов

Пример.

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

void main()
{
  // Метод insert() - вставить диапазон элементов
  // 1. Объявить ассоциативный контейнер
  map<int, double> m1;

  // 2. Сформировать контейнер
  for (int i = 0; i < 10; i++)
    m1.insert(make_pair(i, i * 1.1));

  // 3. Объявить другой ассоциативный контейнер
  map<int, double> m2;

  // 4. Сформировать m2 на основе m1,
  // добавить элементы, которые размещаются в диапазоне [2; 4]
  // 4.1. Объявить итераторы та установить их на соответвующие позиции
  map<int, double>::iterator itFirst = m1.find(2);
  map<int, double>::iterator itLast = m1.find(5);

  // 4.2. Сформировать m2
  m2.insert(itFirst, itLast);

  // 5. Вывести m2
  map<int, double>::iterator it = m2.begin();
  cout << "m2:" << endl;
  while (it != m2.end())
  {
    cout << it->first << " : " << it->second << endl;
    it++;
  }
}

Результат

m2:
2 : 2.2
3 : 3.3
4 : 4.4

⇑

4. Метод swap(). Обменять местами содержимое двух контейнеров

При помощи метода swap() можно обменять содержимое двух контейнеров. Синтаксис объявления метода

inline void swap(map<kType, vType> &_Right);

здесь

kType – тип ключа;
vType – тип значения;
_Right – объект класса map, элементы которого обмениваются с элементами вызывающего объекта.

Тип ключа kType и тип значения vType должны совпадать с типами ключа и значения объекта, который вызывает метод swap().

Пример.

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

void main()
{
  // Метод swap() - обменять местами содержимое контейнеров
  // 1. Создать два контейнера и заполнить их значениями
  // 1.1. Контейнер m1
  map<int, double> m1;
  m1.insert(make_pair(1, 1.1));
  m1.insert(make_pair(5, 5.5));
  m1.insert(make_pair(9, 9.9));

  // 1.2. Контейнер m2
  map<int, double> m2;
  m2.insert(make_pair(2, 2.2));
  m2.insert(make_pair(4, 4.4));

  // 2. Обменять местами контейнеры - метод swap()
  m1.swap(m2);

  // 3. Вывести контейнер m1
  cout << "m1:" << endl;
  map<int, double>::iterator it = m1.begin();
  while (it != m1.end())
  {
    cout << it->first << " : " << it->second << endl;
    it++;
  }

  // 4. Вывести контейнер m2
  cout << "m2:" << endl;
  it = m2.begin();
  while (it != m2.end())
  {
    cout << it->first << " : " << it->second << endl;
    it++;
  }
}

Результат

m1:
2 : 2.2
4 : 4.4
m2:
1 : 1.1
5 : 5.5
9 : 9.9

⇑

5. Операторная функция operator=(). Присвоить один контейнер другому

С помощью операторной функции operator=() реализуется обычная операция присваивания одного контейнера другому. Синтаксис объявления функции

inline map<kType, vType> operator=(const map<kType, vType> &_Right);

здесь

kType – тип ключа;
vType – тип значения;
_Right – объект, размещаемый справа от операции присваивания (контейнер-оригинал). При копировании контейнеров создается полная копия контейнера _Right. Это означает, что после выполнения операции присваивания = оба контейнера размещаются в разных участках памяти.

Пример.

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

void main()
{
  // Операторная функция operator=() - присвоить содержимое контейнера другому
  // 1. Создать контейнер и заполнить его значениями
  map<int, char> m1;
  m1.insert(make_pair(1, 'A'));
  m1.insert(make_pair(2, 'B'));
  m1.insert(make_pair(3, 'C'));

  // 2. Создать другой пустой контейнер
  map<int, char> m2;

  // 3. Вывести размер другого контейнера
  cout << "m2.size = " << m2.size() << endl;

  // 3. Выполнить присваивание контейнеров
  m2 = m1; // вызов операторной функции operator=()

  // 4. Вывести другий контейнер
  map<int, char>::iterator it = m2.begin();
  cout << "m2 => ";
  while (it != m2.end())
  {
    cout << "(" << it->first << ":" << it->second << ") ";
    it++;
  }
  cout << endl;

  // 5. Прибавить к другому контейнеру элемент и повторно вывести его
  m2.insert(make_pair(4, 'D'));
  it = m2.begin();
  cout << "---------------------" << endl;
  cout << "m2 => ";
  while (it != m2.end())
  {
    cout << "(" << (*it).first << ":" << (*it).second << ") ";
    it++;
  }
  cout << endl;

  // 6. Вывести первый контейнер
  cout << "m1 => ";
  it = m1.begin();
  while (it != m1.end())
  {
    cout << "(" << it->first << ":" << it->second << ") ";
    it++;
  }
}

Результат

m2.size = 0
m2 => (1:A) (2:B) (3:C)
---------------------
m2 => (1:A) (2:B) (3:C) (4:D)
m1 => (1:A) (2:B) (3:C)

Как видно из результата, была создана полная копия контейнера m2 в другой области памяти.

BestProg

C++. Класс map. Методы изменяющие данные в контейнере

Класс map. Методы изменяющие данные в контейнере

Содержание

1. Метод clear(). Очистить ассоциативный массив

⇑

2. Метод erase(). Удалить элемент из ассоциативного контейнера

2.1. Удаление одного элемента по заданному ключу

⇑

2.2. Удаление одного элемента, на который указывает итератор

⇑

2.3. Удаление нескольких элементов, которые заданы диапазоном

⇑

3. Метод insert(). Добавить новую пару в массив

3.1. Вставить элементы на основе списка инициализации std::initializer_list

⇑

3.2. Добавить пару в контейнер

⇑

3.3. Вставка диапазона

⇑

4. Метод swap(). Обменять местами содержимое двух контейнеров

⇑

5. Операторная функция operator=(). Присвоить один контейнер другому

⇑

Связанные темы

⇑

Программирование: теория и практика