Класс vector. Методы, изменяющие данные в массиве. Методы push_back(), pop_back(), clear(), swap(), operator=(), erase(), insert(), assign()

Перед изучением данной темы рекомендуется ознакомиться со следующей темой:

• Общие сведения о классе vector. Обзор методов. Создание динамического массива. Способы доступа к элементам вектора

---

Содержание

• 1. Метод push_back(). Добавить элемент в конец вектора
• 2. Метод pop_back(). Удалить последний элемент вектора
• 3. Метод clear(). Удаляет из массива все элементы
• 4. Метод swap(). Обмен местами двух векторов
• 5. Присваивание массивов. Перегруженный оператор =
• 6. Метод erase(). Удалить элемент или несколько элементов указанного диапазона
• 7. Метод insert(). Вставляет элемент или группу элементов в вектор
  • 7.1. Вставка списка инициализации в вектор
  • 7.2. Вставка элемента заданное количество раз в заданную позицию
  • 7.3. Вставка одиночного элемента в заданную позицию
  • 7.4. Вставка нескольких элементов из указанного диапазона
• 8. Метод assign(). Создать массив из существующих данных
• Связанные темы

---

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

1. Метод push_back(). Добавить элемент в конец вектора

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

void vector<T>::push_back(T&& val)
void vector<T>::push_back(const T& val)

здесь T – тип элементов вектора.

Пример.

...

// Метод push_back() - добавить элемент в конец вектора.
// 1. Объявить вектор из 10 элементов типа long long.
vector<long long> A(10);

// 2. Заполнить массив данными
for (int i = 0; i < A.size(); i++)
  A[i] = i * i;

// 3. Добавить элемент в конец массива
A.push_back(10000L);

// 4. Получить новую длину массива
int count = A.size(); // count = 11

...

  ⇑

2. Метод pop_back(). Удалить последний элемент вектора

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

void vector<T>::pop_back()

здесь T – тип элементов массива.

Пример.

...

// Метод pop_back() - удалить последний элемент из массива.
// 1. Объявить указатель на вектор из 5 елементов типа float.
vector<float>* A = new vector<float>(5);

// 2. Заполнить массив данными
A->at(0) = 2.88f;
A->at(1) = 3.8f;
A->operator[](2) = 4.4f; // так тоже можно
A->at(3) = 4.9f;
A->at(4) = 5.5f;

// 3. Вывести массив в строку
for (int i = 0; i < A->size(); i++)
  cout << A->at(i) << " ";

// 4. Удалить последний элемент
A->pop_back();

// 5. Получить новую длину массива
int count = A->size(); // count = 4

...

  ⇑

3. Метод clear(). Удаляет из массива все элементы

Метод clear() предназначен для удаления из массива всех элементов. Длина массива, которая возвращается методом size(), становится равной 0. Синтаксис объявления метода clear() следующий:

void vector<T>::clear()

здесь T – тип элементов массива.

Пример.

...

// Метод clear() - удаляет из массива все элементы.
// 1. Объявить вектор из 10 элементов типа short.
vector<short> A(10);

// 2. Заполнить массив данными
for (int i = 0; i < A.size(); i++)
  A.at(i) = i;

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

// 4. Удалить из массива все элементы
A.clear();

// 5. Повторно вывести размер массива
cout << A.size() << endl; // 0

...

  ⇑

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

Метод swap() используется для обмена двух векторов местами. Типы векторов должны совпадать. Общая форма объявления метода следующая

void vector<T>::swap(vector<T>& _Right)

здесь

• T – тип элементов вектора;
• _Right – массив, который обменивается с текущим массивом.

Пример.

...

// Метод swap() - обмен векторов местами

// 1. Объявить два массива
vector<short> A1;
vector<short> A2;

// 2. Заполнить массив данными
initializer_list<short> L1 = { 1, 2, 3, 4 };
initializer_list<short> L2 = { 5, 6, 7, 8, 9 };
A1.assign(L1); // A1 = { 1, 2, 3, 4 }
A2.assign(L2); // A2 = { 5, 6, 7, 8, 9 }

// 3. Обменять местами два массива
A1.swap(A2); // A1 = { 5, 6, 7, 8, 9 }, A2 = { 1, 2, 3, 4 }

...

  ⇑

5. Присваивание массивов. Перегруженный оператор =

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

Приклад.

...

// Присваивание массивов
// 1. Создать массив целых чисел на основе списка инициализации
initializer_list<int> L = { 1, 2, 3, 4, 5 };
vector<int> A1(L); // A1 = { 1, 2, 3, 4, 5 }

// 2. Объявить другой пустой массив
vector<int> A2;

// 3. Присвоить один массив другому
A2 = A1; // A2 = { 1, 2, 3, 4, 5 }

...

  ⇑

6. Метод erase(). Удалить элемент или несколько элементов указанного диапазона

Метод erase() используется для удаления элементов из динамического массива типа vector. Метод имеет две перегруженные реализации.
Первая реализация имеет следующий синтаксис:

vector<T>::iterator erase(vector<T>::const_iterator First, vector<T>::const_iterator Last)

здесь

• T – тип элементов массива;
• First – итератор, который указывает на первый элемент удаляемого диапазона;
• Last – итератор, указывающий на элемент, находящийся за последним элементом удаляемого диапазона.
  Данная реализация метода erase() возвращает итератор, указывающий на фрагмент исходного массива, который начинается с итератора Last.

Вторая реализация имеет синтаксис:

vector<T>::iterator erase(vector<T>::const_iterator Where)

здесь

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

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

Пример. В примере приведена демонстрационная программа, в которой используется метод erase().

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

void main()
{
  // 1. Создать вектор из 10 целых чисел
  vector<int> A(10);

  // 2. Заполнить вектор данными: A = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
  for (int i = 0; i < A.size(); i++)
    A[i] = i;

  // 3. Вывести массив A на экран
  cout << "A = ";
  for (int i = 0; i < A.size(); i++)
    cout << A[i] << " ";
  cout << endl;

  // 4. Удалить элементы с индексами от 2 до 4 включительно
  // 4.1. Объявить 3 итератора
  vector<int>::iterator it1 = A.begin() + 2; // итератор указывает на элемент с индексом 2
  vector<int>::iterator it2 = A.begin() + 5; // итератор указывает на элемент с индексом 5
  vector<int>::iterator it3; // итератор, который будет указывать на другой фрагмент массива A

  // 4.2. Вызов метода erase() - удалить фрагмент
  it3 = A.erase(it1, it2); // A = [ 0, 1, 5, 6, 7, 8, 9 ]

  // 5. Вывести результат по итератору it3.
  // Итератор указывает на фрагмент массива it3 => [ 5, 6, 7, 8, 9 ]
  cout << "it3 => ";
  while (it3 != A.end())
  {
    cout << *it3 << " ";
    it3++;
  }
  cout << endl;

  // 6. Вывести массив после удаления: A = [ 0, 1, 5, 6, 7, 8, 9 ]
  cout << "A = ";
  for (int i = 0; i < A.size(); i++)
    cout << A[i] << " ";
  cout << endl;

  // 7. Удалить первый элемент в массиве
  // 7.1. Объявить итератор на первый элемент массива
  vector<int>::iterator it4 = A.begin();

  // 7.2. Вызвать метод erase() с параметром одиночного итератора
  A.erase(it4);

  // 7.3. Вывести массив A опять
  cout << "A = ";
  for (int i = 0; i < A.size(); i++)
    cout << A[i] << " ";
  cout << endl;
}

Результат выполнения программы

A = 0 1 2 3 4 5 6 7 8 9
it3 => 5 6 7 8 9
A = 0 1 5 6 7 8 9
A = 1 5 6 7 8 9

  ⇑

7. Метод insert(). Вставляет элемент или группу элементов в вектор

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

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

При этом способе вставки объявление метода insert() следующее:

vector<T>::iterator insert(
    vector<T>::const_iterator _Where,
    initializer_list _Ilist
)

здесь

• T – тип элементов массива;
• initializer_list – тип списка инициализации;
• _Where – итератор, указывающий на позицию вставки;
• _Ilist – список инициализации.

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

Пример.

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

void main()
{
  // Метод insert() - вставка списка инициализации в вектор

  // 1. Объявить массив из 5 элементов типа double
  vector<double> A(5);

  // 2. Заполнить массив числами 1.0
  A.assign(5, 1.0); // A = { 1.0, 1.0, 1.0, 1.0, 1.0 }

  // 3. Вставить список инициализации в позицию 2
  // 3.1. Объявить список инициализации L
  initializer_list<double> L = { 2.2, 3.2 };
 
  // 3.2. Объявить итератор и направить его на позицию 2
  vector<double>::iterator it = A.begin() + 2;

  // 3.3. Вызвать метод insert()
  vector<double>::iterator it2;
  it2 = A.insert(it, L); // A = { 1, 1, 2.2, 3.2, 1, 1, 1 }

  // 4. Вывести измененный массив A
  cout << "A = ";
  for (int i = 0; i < A.size(); i++)
    cout << A[i] << " ";
  cout << endl;

  // 5. Вывести данные по итератору
  cout << "it2 => ";
  while (it2 != A.end())
  {
    cout << *it2 << " ";
    it2++;
  }
}

Результат выполнения программы

A = 1 1 2.2 3.2 1 1 1
it2 => 2.2 3.2 1 1 1

  ⇑

7.2. Вставка элемента заданное количество раз в заданную позицию

Данная реализация метода позволяет вставить элемент в заданную позицию заданное количество раз

vector<T>::iterator insert(
  vector<T>::const_iterator _Where,
  const size_t _Count,
  const T& Val
)

здесь

• T – тип элементов массива;
• _Where – итератор, указывающий на позицию вставки;
• _Count – количество элементов Val, которые нужно вставить в массив;
• Val – элемент, вставляемый в массив.

Пример.

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

void main()
{
  // Метод insert() - вставка элемента указанное количество раз

  // 1. Объявить массив из 5 элементов типа char
  vector<char> A(5);

  // 2. Заполнить массив символами: A = { '-', '-', '-', '-', '-' }
  for (int i = 0; i < A.size(); i++)
    A[i] = '-';

  // 3. Вставить 4 символа '+' в позицию 3 массива
  // 3.1. Объявить итератор на позицию 3
  vector<char>::iterator it = A.begin() + 3;

  // 3.2. Вызвать метод insert()
  vector<char>::iterator it2;
  it2 = A.insert(it, 4, '+');

  // 4. Вывести результирующий массив
  cout << "A = ";
  for (int i = 0; i < A.size(); i++)
    cout << A[i] << " ";
  cout << endl;

  // 5. Вывести фрагмент, на который указывает итератор   it2
  cout << "it2 => ";
  while (it2 != A.end())
  {
    cout << *it2 << " ";
    it2++;
  }
}

Результат выполнения программы

A = - - - + + + + - -
it2 => + + + + - -

  ⇑

7.3. Вставка одиночного элемента в заданную позицию

Для вставки одиночного элемента в позицию, на которую указывает итератор, используется одна из следующих форм метода insert()

vector<T>::iterator insert(vector<T>::const_iterator _Where, T&& _Val)
vector<T>::iterator insert(vector<T>::const_iterator _Where, const T& _Val)

здесь

• T – тип элементов массива;
• _Where – итератор, указывающий на позицию вставки;
• _Val – вставляемое значение.

Данная форма функции возвращает итератор, указывающий на позицию вставки.

Пример.

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

void main()
{
  // Метод insert() - вставка одиночного элемента в заданную позицию

  // 1. Объявить массив из 5 элементов типа short
  vector<short> A(5);

  // 2. Заполнить массив числами на основе списка инициализации
  initializer_list<short> L = { 1, 2, 3, 4, 5 };
  A.assign(L);

  // 3. Вставить в позицию 0 число 100
  // 3.1. Объявить итератор, который указывает на позицию 0
  vector<short>::iterator it = A.begin();

  // 3.2. Вызвать метод insert()
  vector<short>::iterator it2 = A.insert(it, 100);

  // 4. Вывести результирующий массив
  cout << "A = ";
  for (int i = 0; i < A.size(); i++)
    cout << A[i] << " ";
  cout << endl;

  // 5. Вывести фрагмент, на который указывает итератор it2
  cout << "it2 => ";
  while (it2 != A.end())
  {
    cout << *it2 << " ";
    it2++;
  }
}

Результат выполнения программы

A = 100 1 2 3 4 5
it2 => 100 1 2 3 4 5

  ⇑

7.4. Вставка нескольких элементов из указанного диапазона

Для вставки группы элементов из другого массива, которые заданы диапазоном, используется следующая форма метода insert()

vector<T>::iterator insert<_Iter <unnamed>>(
  vector<T>::const_iterator _Where,
  _Iter _First,
  _Iter _Last
)

здесь

• T – тип элементов массива;
• _Where – итератор, который указывает позицию вставки в текущем массиве;
• _First, _Last – итераторы, указывающие на позиции начала и конца диапазона массива, который есть источником.

Метод возвращает итератор, указывающий на позицию вставки.

Пример.

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

void main()
{
  // Метод insert() - вставка группы элементов, заданных диапазоном

  // 1. Объявить два массива
  vector<short> A1(5);
  vector<short> A2(5);

  // 2. Заполнить массивы данными
  initializer_list<short> L1 = { 0, 1, 2, 3, 4 };
  initializer_list<short> L2 = { 5, 6, 7, 8, 9 };
  A1.assign(L1); // A1 = { 0, 1, 2, 3, 4 }
  A2.assign(L2); // A2 = { 5, 6, 7, 8, 9 }

  // 3. Реализовать вставку элементов с индексами [1, 2, 3] массиву A2 в
  // позицию 3 массива A1.
  // Результирующий массив должен быть таким: A1 = { 0, 1, 2, 6, 7, 8, 3, 4 }
  // 3.1. Объявить итератор на массив A1, который указывает на позицию 3
  vector<short>::iterator Where = A1.begin() + 3;

  // 3.2. Объявить итераторы, которые указывают на диапазон [1..3] массива A2
  vector<short>::iterator First = A2.begin() + 1;
  vector<short>::iterator Last = A2.begin() + 4; // следующий после 3

  // 3.3. Вызвать метод insert(), получить результирующий итератор
  vector<short>::iterator Result;
  Result = A1.insert(Where, First, Last);

  // 4. Вывести результирующий массив
  cout << "A1 = { ";
  for (int i = 0; i < A1.size(); i++)
    cout << A1[i] << " ";
  cout << "}" << endl;

  // 5. Вывести фрагмент, на который указывает итератор Result
  cout << "Result => ";
  while (Result != A1.end())
  {
    cout << *Result << " ";
    Result++;
  }
}

Результат выполнения программы

A1 = { 0 1 2 6 7 8 3 4 }
Result => 6 7 8 3 4

  ⇑

8. Метод assign(). Создать массив из существующих данных

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

Первая реализация позволяет изменить существующий массив и заполнить его значениями

void assign(const size_t NewSize, const T& val)

здесь

• T – тип элементов массива;
• NewSize – новый размер массива (количество элементов);
• val – значения, которыми заполняется массив.

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

void assign<_Iter, <unnamed>>(_Iter First, _Iter Last)

здесь

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

Третья реализация позволяет сформировать массив из списка инициализации

void assign(initializer_list<T> _Ilist)

здесь

• T – тип элементов массива;
• _Ilist – список инициализации.

Пример.

...

// Метод assign() - получить новый массив на основе данных.
// 1. Объявить массив из 0 элементов типа int
vector<int> A;

// 2. Заполнить массив A значениями 20
A.assign(3, 20); // A = [ 20, 20, 20 ]

// 3. Объявить новый массив из чисел и заполнить его данными
vector<int> A2(5);
A2[0] = 10;
A2[1] = 22;
A2[2] = 33;
A2[3] = 41;
A2[4] = 54;

// 4. С помощью итераторов создать массив A на основе A2.
// Взять элементы с позициями от 2 до 4 включительно
vector<int>::iterator iStart;
vector<int>::iterator iEnd;
iStart = A2.begin() + 2; // установить итератор на начало массива
iEnd = A2.begin() + 5; // установить итератор на конец массива
A.assign(iStart, iEnd); // A = [ 33, 41, 54 ]

// 5. Создать новый массив типа float на основе списка инициализации
// 5.1. Объявить список инициализации
initializer_list<float> L = { 1.5f, 2.3f, -4.2f, 3.8f };

// 5.2. Объявить пустой массив типа float
vector<float> A3;

// 5.3. Инициализировать массив A3 списком L
A3.assign(L);

cout << "------------" << endl;
for (int i = 0; i < A3.size(); i++)
  cout << A3[i] << " ";
cout << endl;

...

  ⇑

---

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

• Общие сведения о классе vector. Обзор методов. Создание динамического массива. Способы доступа к элементам вектора
• Методы, определяющие и изменяющие общие характеристики массива: size(), max_size(), capacity(), empty(), shrink_to_fit(), resize(), reserve()
• Методы, обеспечивающие доступ к элементам массива: at(), front(), back(), data(), begin(), end(), cbegin(), cend(), rbegin(), rend(), crbegin(), crend()

  ⇑

---