Динамические массивы и переменные: легко и просто!
Всем привет! В этой статье мы создадим массив и переменные применяя указатели. Если вы еще не почитали прошлую (начальную) статью про указатели, то советуем сначала изучить ее. Ну а если вы это все знаете, то погнали!
Быстрый переход по статье.
Что такое динамические переменные
Динамические переменные — это переменные, которые созданы напрямую с помощью указателей. Для них существует функция удаление (это мы разберем ниже).
Чтобы мы могли полноценно создавать динамические переменные, нам понадобится изучить конструктор — new, после его использования в оперативной памяти компьютера выделяются ячейки на тот тип данных, который мы указали.
На каждый тип данных выделяется разное количество ячеек.
Как создать динамические переменные в C++
Для создания динамических переменных нам понадобится применять конструкцию ниже:
|
1 |
<тип данных указателя> *<имя указателя> = new <тип данных>(<первоначальное значение>); |
Давайте подробно ее разберем:
<тип данных указателя>— указанный тип данных почти ни на что не повлияет. Читайте ниже.new— это конструктор, который и будет заключительным звеном для создания нашей переменной.<тип данных>— здесь нам понадобится указать тип, какой будет храниться в переменной. Он необязательно должен совпадать с типом указателя.<первоначальное значение>— с помощью круглых скобок можно указать значение переменной еще при ее инициализации. Использование круглых скобок в этой конструкции необязательно.
Вы должны знать! Если тип переменной отличается от типа указателя — то эта динамическая переменная будет весить больше в оперативной памяти, чем такая же переменная с одинаковыми типами!
Пример использования динамических переменных
Внизу мы решили использовать динамические переменные:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#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: выводим значение нашей переменной на экран.
Важно помнить! Динамические переменные — это указатели, и поэтому перед ними обязательно должен стоять оператор *.
Удаление динамических переменных
Как мы говорили выше, у нас есть возможность освобождать память переменной или, если понятным языком, удалять переменную из оперативной памяти ПК.
Конечно, эта переменная и так удалится из оперативной памяти компьютера при завершении программы. Но если нам захотелось удалить ее еще в середине программы, то это будет возможно благодаря оператору delete.
Чтобы его использовать, нужно применить конструкцию ниже:
|
1 |
delete <имя переменной>; |
- В самом начале мы используем оператор
delete. - Дальше идет имя переменной.
Вы должны обратить внимание на отсутствие оператора * перед именем переменной. Многие начинающие прогеры забывают про это и в дальнейшем пытаются найти ошибку часами.
Статическое и динамическое объявление переменных
Статическое объявление переменных имеет такой вид:
int number;
Использование динамических переменных имеет маленький плюс. Он заключается в освобождении памяти переменной до завершения программы. Благодаря этому мы можем сначала удалить переменную, а потом ее снова создать в другом участке программы (когда это нам будет нужно).
Что такое динамические массивы
Мы уже знакомы с миром массивов в C++. Мы не раз создавали их на определенное количество ячеек и при этом использовали статическое создание массивов.
|
1 |
int array[100]; |
Но еще ни разу не затрагивали их использование с указателями!
Мы создавали массивы на сто тысяч элементов, а то и больше. И не один раз бывало, что большое количество ячеек оставались неиспользованными. Это является неправильным применением оперативной памяти в ПК.
Чтобы мы бесполезно не использовали оперативную память в компьютере, нам понадобится оперировать с указателями в свете массивов.
Нам нужно вспомнить, что для создания статического массива количество ячеек нужно задавать числовой константой (а не переменной). Это очень неприятно, потому что в программе мы не знаем, сколько нам может понадобится ячеек.
Например, пользователь захотел вписать 1000 чисел в массив, а мы из-за незнания этого факта сделали массив всего лишь на 500 ячеек.
Динамический массив — это массив, у которого количество ячеек можно задавать и переменной, и числовой константой. Это большой плюс перед использованием статического массива.
Как работают динамические массивы
Для работы динамических массивов нам понадобится при инициализации указатель (всего лишь при инициализации!) и уже знакомый конструктор new.
Как создать динамический массив в C++
Чтобы создать динамический массив мы будем использовать конструкцию ниже:
|
1 |
<тип данных> *<имя массива> = new <тип переменных> [<количество ячеек>]; |
<тип данных>— без разницы какой тип данных тут будет находиться, но лучше тот, который будет совпадать с типом переменных.<тип переменных>— указанный сюда тип и будут иметь ячейки массива.<количество ячеек>— здесь мы задаем размер массива (например[n]или[25]).
Динамический массив полностью идентичен обычному массиву, кроме:
- Своей инициализации
- Возможностью своевременно освободить память.
Давайте рассмотрим пример с использованием динамического массива:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
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; } |
Вот что будет при выполнении программы:
Удаление динамического массива
Для удаления динамического массива нам понадобится уже знакомый оператор — delete.
|
1 |
delete [] <имя массива>; |
Важно запомнить, что квадратные скобки нужно ставить перед <именем массива>.
Как создать двумерный динамический массив в C++
Для создания двумерного динамического массива мы будем использовать похожую конструкцию (как и в одномерном динамическом массиве):
|
1 |
<тип данных> **<имя массива> = new <тип данных массива>* [<количество ячеек>]; |
Вам нужно обратить внимание на:
- Дополнительный оператор
*перед<имя массива>и после<тип данных массива>.
Дальше для каждой ячейки мы должны создать одномерный массив. Чтобы это сделать, нам понадобится цикл for и конструктор new.
|
1 2 3 4 5 |
for (int i = 0; i < n; i++) { <имя массива>[i] = new <тип ячеек> [<количество ячеек>]; } |
В <количество ячеек> можно задавать разные значения. Поэтому сначала для первого массива можно задать длину 1 (new int [1]), потом для второго — длину 2 (new int [2]), как в примере ниже.
Внизу находится пример двумерного динамического массива:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
#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, и после <имя массива> находится индекс того массива который будет удален.
|
1 2 3 4 5 |
for (int i = 0; i < <количество элементов в массиве>; i++) { delete [] <имя массива>[i]; } |
Тест на тему «Динамические массивы и переменные». Проверь себя!
Если эта надпись не исчезает долгое время, попробуйте обновить страницу. Этот тест использует javascript. Пожалуйста, влкючите javascript в вашем браузере.
На этом у нас все! Если есть вопрос, пишите в комментариях. Удачи!
Классный сайт, буду продолжать учить C++ на нем и дальше. Эта статья про динамические массивы и переменные в C++ очень мне помогла. Я смог узнать зачем они применяются, как используются в программе. А очень порадовала информация про создания двумерного динамического массива в C++. Давно хотел найти, но нигде не было информации. И да еще про их удаление очень понравилось. Вообщем спасибо, что помогаете новичкам становиться мастерами! Так держать !
Да не за что Максим! Будем вас радовать такими статьями и дальше!
Почему объявление динамического массива осуществляется именно за счет указателя,а не переменной по тому же принципу?
Подскажите, пожалуйста! в каком месте программы объявлять двумерный динамический массив. int main отсутствует. объявляю вместе, где все переменные, но на for ругается. использую c++ builder embarcadero
Попробуй использовать Code Blocks или Dev-C++.
Спасибо. Статья помогла!
В тесте Вопрос 2
Какая библиотека нужно для создания динамических переменных и массивов?
Показывает только последний ответ (никакой).
Остальные ответы отсутствуют. Просто белые поля. Прошу проверить код страницы. Отключение Антирекламных плагинов, и изменение размера страницы не меняют дела.
Исправил, спасибо!