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

Клас 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

 

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

Дана реалізація методу 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 в іншій області пам’яті.

 


Споріднені теми