Динамические массивы и переменные в C++: легко и просто!

Всем привет! В этой статье мы создадим массив и переменные применяя указатели. Если вы еще не почитали прошлую (начальную) статью про указатели, то советуем сначала изучить ее. Ну а если вы это все знаете, то погнали!

Интересное

Последние новости в мире программирования

Самые свежие новости и полезные материалы в моем telegram канале.

Что такое динамические переменные

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

Чтобы мы могли полноценно создавать динамические переменные, нам понадобится изучить конструктор - new, после его использования в оперативной памяти компьютера выделяются ячейки на тот тип данных, который мы указали.

На каждый тип данных выделяется разное количество ячеек.

Как создать динамические переменные в C++

Для создания динамических переменных нам понадобится применять конструкцию ниже:

<тип данных указателя> *<имя указателя> = new <тип данных>(<первоначальное значение>);

Давайте подробно ее разберем:

• <тип данных указателя> - указанный тип данных почти ни на что не повлияет. Читайте ниже.
• new - это конструктор, который и будет заключительным звеном для создания нашей переменной.
• <тип данных> - здесь нам понадобится указать тип, какой будет храниться в переменной. Он необязательно должен совпадать с типом указателя.
• <первоначальное значение> - с помощью круглых скобок можно указать значение переменной еще при ее инициализации. Использование круглых скобок в этой конструкции необязательно.

Вы должны знать! Если тип переменной отличается от типа указателя - то эта динамическая переменная будет весить больше в оперативной памяти, чем такая же переменная с одинаковыми типами!

Пример использования динамических переменных

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

#include <iostream>

using namespace std;

int main() {
  setlocale(0, "");
  int *a = new int;

  int b = 10;

  *a = b;

  cout <<"Теперь переменная a равна "<< *a << endl;

  cout <<"Пришло время удалить эту переменную!";

  system("pause");
  return 0;
}

• В строке 7: мы объявили переменную, оперируя конструктором new.
• Дальше в строке 11: значение нашей переменной становится равно 10.
• И в самом конце, в строке 15: выводим значение нашей переменной на экран.

Важно помнить! Динамические переменные - это указатели, и поэтому перед ними обязательно должен стоять оператор *.

Интересное

Последние новости в мире программирования

Самые свежие новости и полезные материалы в моем telegram канале.

Удаление динамических переменных

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

Конечно, эта переменная и так удалится из оперативной памяти компьютера при завершении программы. Но если нам захотелось удалить ее еще в середине программы, то это будет возможно благодаря оператору delete.

Чтобы его использовать, нужно применить конструкцию ниже:

delete <имя переменной>;

• В самом начале мы используем оператор delete.
• Дальше идет имя переменной.

Вы должны обратить внимание на отсутствие оператора * перед именем переменной. Многие начинающие прогеры забывают про это и в дальнейшем пытаются найти ошибку часами.

Статическое и динамическое объявление переменных

Статическое объявление переменных имеет такой вид: int number;

Использование динамических переменных имеет маленький плюс. Он заключается в освобождении памяти переменной до завершения программы. Благодаря этому мы можем сначала удалить переменную, а потом ее снова создать в другом участке программы (когда это нам будет нужно).

Что такое динамические массивы

Мы уже знакомы с миром массивов в C++. Мы не раз создавали их на определенное количество ячеек и при этом использовали статическое создание массивов.

int array[100];

Но еще ни разу не затрагивали их использование с указателями!

Мы создавали массивы на сто тысяч элементов, а то и больше. И не один раз бывало, что большое количество ячеек оставались неиспользованными. Это является неправильным применением оперативной памяти в ПК.

Чтобы мы бесполезно не использовали оперативную память в компьютере, нам понадобится оперировать с указателями в свете массивов.

Нам нужно вспомнить, что для создания статического массива количество ячеек нужно задавать числовой константой (а не переменной). Это очень неприятно, потому что в программе мы не знаем, сколько нам может понадобится ячеек.

Например, пользователь захотел вписать 1000 чисел в массив, а мы из-за незнания этого факта сделали массив всего лишь на 500 ячеек.

Динамический массив - это массив, у которого количество ячеек можно задавать и переменной, и числовой константой. Это большой плюс перед использованием статического массива.

Интересное

Последние новости в мире программирования

Самые свежие новости и полезные материалы в моем telegram канале.

Как работают динамические массивы

Для работы динамических массивов нам понадобится при инициализации указатель (всего лишь при инициализации!) и уже знакомый конструктор new.

Как создать динамический массив в C++

Чтобы создать динамический массив мы будем использовать конструкцию ниже:

<тип данных> *<имя массива> = new <тип переменных> [<количество ячеек>];

• <тип данных> - без разницы какой тип данных тут будет находиться, но лучше тот, который будет совпадать с типом переменных.
• <тип переменных> - указанный сюда тип и будут иметь ячейки массива.
• <количество ячеек> - здесь мы задаем размер массива (например [n] или [25]).

Динамический массив полностью идентичен обычному массиву, кроме:

• Своей инициализации
• Возможностью своевременно освободить память.

Давайте рассмотрим пример с использованием динамического массива:

int main() {
  setlocale(0, "");

  int n;

  cout << "Введите количество чисел, которое вы хотите ввести: ";
  cin >> n;

  cout << "Введите " << n << " чисел: "; 
                                        
  int *dinamich_array = new int [n];    // создаем
                                        // динамический массив
  for (int i = 0; i < n; i++) { 
    cin >> dinamich_array[i];  // считываем числа в ячейки массива
  }

  cout << "Теперь давайте выведем элементы массива в обратном порядке: ";

  for (int i = n - 1 ; i >= 0; i--) {
    cout << dinamich_array[i] << " ";  // выводим значение всех ячеек
  }

  cout << endl << "Удаляем массив!";

  delete [] dinamich_array;  // удаляем динамический массив

  return 0;
}

Вот что будет при выполнении программы:

Задайте количество чисел, которое вы хотите ввести: 5
Введите 5 чисел: 2 4 6 8 16
Теперь давайте выведем элементы массива в обратном порядке: 16 8 6 4 2
Удаляем массив!
Process returned 0 (0x0) execution time : 0.010 s
Press any key to continue.

Удаление динамического массива

Для удаления динамического массива нам понадобится уже знакомый оператор - delete.

delete [] <имя массива>;

Важно запомнить, что квадратные скобки нужно ставить перед <именем массива>.

Интересное

Последние новости в мире программирования

Самые свежие новости и полезные материалы в моем telegram канале.

Как создать двумерный динамический массив в C++

Для создания двумерного динамического массива мы будем использовать похожую конструкцию (как и в одномерном динамическом массиве):

<тип данных> **<имя массива> = new <тип данных массива>* [<количество ячеек>];

Вам нужно обратить внимание на:

• Дополнительный оператор * перед <имя массива> и после <тип данных массива>.

Дальше для каждой ячейки мы должны создать одномерный массив. Чтобы это сделать, нам понадобится цикл for и конструктор new.

for (int i = 0; i < n; i++) {

  <имя массива>[i] = new <тип ячеек> [<количество ячеек>];

}

В <количество ячеек> можно задавать разные значения. Поэтому сначала для первого массива можно задать длину 1 (new int [1]), потом для второго - длину 2 (new int [2]), как в примере ниже.

Внизу находится пример двумерного динамического массива:

#include <iostream>

using namespace std;

int main() {
  setlocale(0, "");

  int **dinamic_array2 = new int* [5];   // создаем 
  for (int i = 0; i < 5; i++) {          // двумерный
    dinamic_array2[i] = new int [i + 1]; // массив 
  }                                      // !

  for (int i = 0; i < 5; i++) {
    cout << "Введите числа" << "(" << i + 1 << ")" << ":";
    for (int j = 0; j < i + 1; j++) { 
      cin >> dinamic_array2[i][j];
    }
  }

  for (int i = 0; i < 5; i++) {
    int sum = 0;
    for (int j = 0; j < i + 1; j++) {
      sum += dinamic_array2[i][j];
    }
    cout << "Сумма " << i + 1 << " массива равна " << sum << endl;
  }

  for (int i = 0; i < 5; i++) {
    delete [] dinamic_array2[i];  // удаляем массив
  }

  system("pause");
  return 0;
}

• В строках 8 - 11: создали двумерный динамический массив.
• В строках 13 - 18: заполнили массив.
• В строках 20 - 26: подсчитали и вывели по отдельности на экран сумму всех массивов.
• В строках 28 - 30: происходит удаление массива (об этом ниже).

Удаление двумерного динамического массива

Для удаление двумерного динамического массива мы будем использовать уже похожую схему. Но в ней присутствует цикл for, и после <имя массива> находится индекс того массива который будет удален.

for (int i = 0; i < <количество элементов в массиве>; i++) {

  delete [] <имя массива>[i];

}

На этом у нас все! Если есть вопрос, пишите в комментариях. Удачи!

« Векторы в C++

Указатели в C++ »