Содержание
В прошлой статье мы научились выделять память в куче: создавать одномерный массив через new[] и освобождать его через delete[]. А ещё раньше, в уроке про двумерные массивы, работали с матрицами. Сегодня соединим эти темы.
В этой статье разберём динамические матрицы в C++: как матрица устроена «под капотом», как выделить под неё память в куче, как на самом деле работает двойная индексация matrix[i][j] и как правильно освободить память, чтобы не было утечки. Это завершающий урок небольшого цикла про указатели и динамическую память — ещё один взгляд на ту же тему с другой стороны.
После этой статьи Вы сможете:
- объяснить, почему матрица — это массив указателей на строки;
- прочитать тип
int **и понять, что хранит переменнаяmatrix; - выделить память под матрицу любого размера, в том числе введённого с клавиатуры;
- расписать
matrix[i][j]через адресную арифметику и разыменование; - освободить память матрицы в правильном порядке;
- поменять местами две строки матрицы за одно действие;
- решить пять задач к уроку: три теста и две задачи на программирование.
Что такое динамическая матрица
Вспомним два факта из прошлых уроков. Первый: двумерный массив, или матрица, — это массив массивов, то есть массив, элементами которого являются другие массивы — строки. Второй: имя массива — это указатель на его нулевой элемент, правило array decays to pointer.
Соединим их. Раз матрица — массив массивов, а каждый массив — это указатель на свой нулевой элемент, значит, матрицу можно хранить как массив указателей:
Эта мысль проходит через весь урок, поэтому посмотрим на неё на схеме. Пока без точных адресов — только общая идея:
Как прочитать тип int **
Переменная матрицы объявляется с двумя звёздочками: int **matrix. Читать такой тип удобно справа налево:
- правая звёздочка говорит, что
matrix— указатель, то есть хранит адрес; - всё, что левее, —
int *, — тип элемента, на который указываетmatrix. Это указатель наint.
Получается, matrix — указатель на указатель на int: он хранит адрес массива указателей int *, а каждый из них — адрес первого int своей строки. Мы уже встречали указатель на указатель в уроке про указатели, а теперь у него появилось настоящее применение.
Как выделить память под матрицу
Разберём программу, которая создаёт матрицу из 3 строк и 5 столбцов, заполняет её, выводит на экран и освобождает память:
#include <iostream>
int main() {
const int ROWS = 3, COLS = 5;
int **matrix = new int*[ROWS];
for (int i = 0; i < ROWS; i++) {
matrix[i] = new int[COLS];
}
// Работа с матрицей
for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
matrix[i][j] = i * COLS + j;
}
}
for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
std::cout << matrix[i][j] << "\t";
}
std::cout << "\n";
}
for (int i = 0; i < ROWS; i++) {
delete[] matrix[i];
}
delete[] matrix;
return 0;
}
0 1 2 3 4
5 6 7 8 9
10 11 12 13 14
Process finished with exit code 0
Выделение памяти занимает всего несколько строк. Разберём их по порядку.
Шаг 1. Массив указателей: new int*[ROWS]
Строка int **matrix = new int*[ROWS]; устроена так же, как выделение обычного динамического массива:
new— запрос памяти у операционной системы;int*— тип элементов: нам нужны указатели наint;[ROWS]— сколько таких элементов нужно: по одному указателю на каждую строку, всего 3.
Каждый указатель занимает 8 байт, поэтому new выделит 3 · 8 = 24 байта и вернёт адрес их начала. Этот адрес мы кладём в matrix. Раз new int*[...] возвращает адрес указателя, у переменной должно быть две звёздочки: int **.
Шаг 2. Строки: matrix[i] = new int[COLS]
В цикле для каждого i выполняется matrix[i] = new int[COLS];. Правая часть — это обычное выделение одномерного массива из 5 элементов int (5 · 4 = 20 байт). Оператор new возвращает адрес первого байта строки, и мы записываем его в i-ю ячейку массива указателей.
Вспомним, что matrix[i] — это *(matrix + i): сдвигаемся от начала массива указателей на i элементов и попадаем в нужную ячейку. В примере из видео строки получили адреса 0x28, 0x3c и 0x60 — именно они и легли в массив указателей:
Размеры матрицы с клавиатуры
Главное преимущество динамической матрицы — её размеры могут быть переменными, известными только во время работы программы. Например, прочитаем матрицу n × m и посчитаем сумму элементов на главной диагонали:
#include <iostream>
int main() {
int n, m;
std::cin >> n >> m;
int **matrix = new int*[n];
for (int i = 0; i < n; i++) {
matrix[i] = new int[m];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
std::cin >> matrix[i][j];
}
}
// сумма элементов главной диагонали (для квадратной части матрицы)
long long sum = 0;
for (int i = 0; i < n && i < m; i++) {
sum += matrix[i][i];
}
std::cout << sum << "\n";
for (int i = 0; i < n; i++) {
delete[] matrix[i];
}
delete[] matrix;
return 0;
}
3 4
1 2 3 4
5 6 7 8
9 10 11 12
18
Обычный массив int a[n][m] с размерами-переменными стандарт C++ не разрешает, а массив «с запасом» int a[100000][100000] занял бы 40 ГБ. Динамическая матрица занимает ровно столько памяти, сколько нужно.
Как работает matrix[i][j]
Почему для массива указателей работает привычная запись с двумя парами квадратных скобок? Чтобы ответить, вспомним правило из прошлого урока: a[i] — это *(a + i). Применим его к matrix[1][3] дважды — сначала к первым скобкам, потом ко вторым:
matrix[1][3]
= (*(matrix + 1))[3]
= *(*(matrix + 1) + 3)
Возьмём ту же память, что на схеме выше: в строке 1 лежат числа 777, 65304, −254, 6, 1. Проследим вычисление по шагам:
| Выражение | Значение | Что происходит |
|---|---|---|
matrix | 0x0 | Адрес начала массива указателей |
matrix + 1 | 0x8 | Сдвиг на 1 элемент типа int *, то есть на 8 байт |
*(matrix + 1) | 0x3c | Содержимое ячейки 0x8 — адрес начала строки 1. Это всё ещё адрес, а не число! |
*(matrix + 1) + 3 | 0x48 | Сдвиг на 3 элемента типа int: 3 · 4 = 12 байт, 0x3c + 0xc = 0x48 |
*(*(matrix + 1) + 3) | 6 | Содержимое ячейки 0x48 — сам элемент |
Проверим в программе — все три записи выведут одно и то же:
#include <iostream>
int main() {
const int ROWS = 3, COLS = 5;
int values[ROWS][COLS] = {{984, -2, 0, 56, 0},
{777, 65304, -254, 6, 1},
{54, -1, 0, 151, 7}};
int **matrix = new int*[ROWS];
for (int i = 0; i < ROWS; i++) {
matrix[i] = new int[COLS];
for (int j = 0; j < COLS; j++) {
matrix[i][j] = values[i][j];
}
}
std::cout << matrix[1][3] << "\n";
std::cout << (*(matrix + 1))[3] << "\n";
std::cout << *(*(matrix + 1) + 3) << "\n";
for (int i = 0; i < ROWS; i++) {
delete[] matrix[i];
}
delete[] matrix;
return 0;
}
6
6
6
Рисовать адреса при решении задач не нужно: там удобнее представлять матрицу как обычную таблицу чисел. Но один раз разобраться, что происходит внутри, полезно — такие вопросы любят задавать на экзаменах в университете, а понимание пригодится, когда дойдём до функций и объектов.
Как освободить память матрицы
Память матрицы освобождается в обратном порядке относительно выделения. Выделяли сначала массив указателей, потом строки — значит, удаляем сначала строки, а потом массив указателей:
for (int i = 0; i < ROWS; i++) {
delete[] matrix[i];
}
delete[] matrix;
При i = 0 берём из массива указателей адрес 0x28 и передаём его delete[] — строка 0 освобождена. Так же освобождаются строки с адресами 0x3c и 0x60. Последней строкой delete[] matrix освобождаем сам массив указателей по адресу 0x0.
Посчитаем вызовы: new[] выполнился ROWS + 1 раз — один раз для массива указателей и по разу для каждой строки. Столько же раз должен выполниться delete[].
| Выделение | Освобождение | Сколько раз |
|---|---|---|
matrix[i] = new int[COLS]; | delete[] matrix[i]; | ROWS — по разу на строку |
int **matrix = new int*[ROWS]; | delete[] matrix; | Один раз, последним |
Обмен строк — это обмен указателей
У динамической матрицы есть приятная особенность. Чтобы поменять местами две строки обычной матрицы, нужно поэлементно обменять все m чисел. В динамической матрице строки лежат отдельно, а в массиве указателей хранятся только их адреса — достаточно обменять два указателя:
#include <iostream>
int main() {
const int ROWS = 3, COLS = 3;
int values[ROWS][COLS] = {{3, 8, 1}, {4, 5, 6}, {9, 2, 7}};
int **matrix = new int*[ROWS];
for (int i = 0; i < ROWS; i++) {
matrix[i] = new int[COLS];
for (int j = 0; j < COLS; j++) {
matrix[i][j] = values[i][j];
}
}
// меняем местами строки 0 и 2: переставляем только два указателя
int *tmp = matrix[0];
matrix[0] = matrix[2];
matrix[2] = tmp;
for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
std::cout << matrix[i][j] << " ";
}
std::cout << "\n";
}
for (int i = 0; i < ROWS; i++) {
delete[] matrix[i];
}
delete[] matrix;
return 0;
}
9 2 7
4 5 6
3 8 1
Сами строки при этом не копируются, поэтому обмен выполняется за одно действие при любой длине строки. Эта идея пригодится во второй задаче контеста.
Частые ошибки при работе с динамическими матрицами
| Ошибка | Что происходит | Как исправить |
|---|---|---|
int *matrix = new int*[rows]; | Ошибка компиляции: адрес указателя кладётся в указатель на int | Две звёздочки: int **matrix |
int **matrix = new int[rows][cols]; | Ошибка компиляции: так нельзя выделить двумерный массив с размерами-переменными | Сначала new int*[rows], потом в цикле new int[cols] |
Забыли цикл matrix[i] = new int[cols] | Указатели строк содержат мусор, обращение к matrix[i][j] — неопределённое поведение | Выделить каждую строку перед использованием |
new int*[cols] вместо new int*[rows] | Если строк больше, чем столбцов, — выход за границу массива указателей | Указателей столько, сколько строк |
delete[] matrix; до цикла по строкам | Утечка памяти и неопределённое поведение | Сначала строки, потом массив указателей |
Только delete[] matrix; | Строки остаются занятыми — утечка памяти | Освободить каждую строку в цикле |
delete вместо delete[] | Неопределённое поведение | Память из new[] освобождается только delete[] |
Задачи на динамические матрицы
Закрепите материал в контесте к уроку. В нём пять заданий:
- Выделение памяти под матрицу. Выберите фрагмент, который правильно создаёт матрицу
rows × cols. - Очистка памяти матрицы. Найдите все фрагменты, которые освобождают память без утечек и неопределённого поведения.
- Разыменование и оператор []. Посчитайте, что выведет программа с записями
*(*(matrix + 2) + 1),*(matrix[1] + 3)и(*matrix)[2]. - Строка большой матрицы. Прочитайте матрицу, в которой может быть до 100 000 строк или до 100 000 столбцов, и выведите её
k-ю строку. - Обмен строк с максимумом и минимумом. Найдите строки с максимальным и минимальным элементами и поменяйте их местами — подойдёт идея с обменом указателей.
Решая задачи, рисуйте память: где лежит массив указателей, где — строки, какой адрес хранится в matrix[i]. Так ошибки становятся видны ещё до запуска программы.
Подведём итоги
В этой статье Вы научились работать с динамическими матрицами и увидели, как матрица устроена в памяти.
Главное, что нужно запомнить:
- динамическая матрица — это массив указателей на строки, а каждая строка — обычный одномерный динамический массив;
int **matrix = new int*[ROWS];выделяет массив указателей, поэтому уmatrixдве звёздочки;matrix[i] = new int[COLS];выделяет каждую строку — так же, как обычный одномерный массив;- строки не обязаны лежать в памяти подряд;
matrix[i][j]— это*(*(matrix + i) + j): первая пара скобок даёт адрес строки, вторая — значение элемента;- память освобождается в обратном порядке: сначала
delete[] matrix[i]для каждой строки, затемdelete[] matrix; - чтобы поменять строки местами, достаточно обменять два указателя.
Этим уроком мы завершаем цикл про указатели и динамическую память. В следующем уроке познакомимся с функциями: научимся разбивать программу на части и передавать в них данные — в том числе массивы и матрицы.
Теория без практики быстро забывается, поэтому обязательно закрепите материал. Авторизуйтесь на сайте, отметьте статью как прочитанную и перейдите во вкладку «Решать задачи». Отправляйте решения на проверку, разбирайте результаты тестов и отслеживайте свой прогресс.
Продолжить изучение динамической памяти, функций и объектно-ориентированного программирования можно в курсе C++ с нуля с автоматической проверкой задач.
Использованная литература
- Рабочий проект стандарта C++: выражение new [Электронный ресурс]. — URL: https://eel.is/c++draft/expr.new (дата обращения: 21.11.2026).
- Рабочий проект стандарта C++: выражение delete [Электронный ресурс]. — URL: https://eel.is/c++draft/expr.delete (дата обращения: 21.11.2026).
- Рабочий проект стандарта C++: индексирование [Электронный ресурс]. — URL: https://eel.is/c++draft/expr.sub (дата обращения: 21.11.2026).
- Рабочий проект стандарта C++: аддитивные операторы [Электронный ресурс]. — URL: https://eel.is/c++draft/expr.add (дата обращения: 21.11.2026).
- Выражение new [Электронный ресурс]. — URL: https://en.cppreference.com/w/cpp/language/new (дата обращения: 21.11.2026).
- Выражение delete [Электронный ресурс]. — URL: https://en.cppreference.com/w/cpp/language/delete (дата обращения: 21.11.2026).
- Встроенный оператор индексирования [Электронный ресурс]. — URL: https://en.cppreference.com/w/cpp/language/operator_member_access (дата обращения: 21.11.2026).