Динамические матрицы в C++: int**, new[] и delete[]

Девятый урок по C++ с нуля: матрица как массив указателей, выделение памяти через int** и new[], как работает matrix[i][j] под капотом, правильная очистка памяти и обмен строк. Схемы из видеоурока и пять задач с проверкой.

Содержание

В прошлой статье мы научились выделять память в куче: создавать одномерный массив через new[] и освобождать его через delete[]. А ещё раньше, в уроке про двумерные массивы, работали с матрицами. Сегодня соединим эти темы.

В этой статье разберём динамические матрицы в C++: как матрица устроена «под капотом», как выделить под неё память в куче, как на самом деле работает двойная индексация matrix[i][j] и как правильно освободить память, чтобы не было утечки. Это завершающий урок небольшого цикла про указатели и динамическую память — ещё один взгляд на ту же тему с другой стороны.

После этой статьи Вы сможете:

  • объяснить, почему матрица — это массив указателей на строки;
  • прочитать тип int ** и понять, что хранит переменная matrix;
  • выделить память под матрицу любого размера, в том числе введённого с клавиатуры;
  • расписать matrix[i][j] через адресную арифметику и разыменование;
  • освободить память матрицы в правильном порядке;
  • поменять местами две строки матрицы за одно действие;
  • решить пять задач к уроку: три теста и две задачи на программирование.

Что такое динамическая матрица

Вспомним два факта из прошлых уроков. Первый: двумерный массив, или матрица, — это массив массивов, то есть массив, элементами которого являются другие массивы — строки. Второй: имя массива — это указатель на его нулевой элемент, правило array decays to pointer.

Соединим их. Раз матрица — массив массивов, а каждый массив — это указатель на свой нулевой элемент, значит, матрицу можно хранить как массив указателей:

Эта мысль проходит через весь урок, поэтому посмотрим на неё на схеме. Пока без точных адресов — только общая идея:

Динамическая матрица: переменная int **matrix указывает на массив из трёх указателей int*. Каждый указатель matrix[0], matrix[1], matrix[2] хранит адрес начала своей строки из пяти int.
Рисунок 1 — Матрица — это массив указателей на строки

Как прочитать тип int **

Переменная матрицы объявляется с двумя звёздочками: int **matrix. Читать такой тип удобно справа налево:

  • правая звёздочка говорит, что matrix — указатель, то есть хранит адрес;
  • всё, что левее, — int *, — тип элемента, на который указывает matrix. Это указатель на int.

Получается, matrix — указатель на указатель на int: он хранит адрес массива указателей int *, а каждый из них — адрес первого int своей строки. Мы уже встречали указатель на указатель в уроке про указатели, а теперь у него появилось настоящее применение.

Как выделить память под матрицу

Разберём программу, которая создаёт матрицу из 3 строк и 5 столбцов, заполняет её, выводит на экран и освобождает память:

main.cpp
C++
#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;
}
terminal
Bash
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 — именно они и легли в массив указателей:

Память после выделения матрицы 3 на 5: по адресам 0x0, 0x8 и 0x10 лежат три указателя со значениями 0x28, 0x3c и 0x60. Строка 0 занимает адреса 0x28–0x38, строка 1 — 0x3c–0x4c, строка 2 — 0x60–0x70.
Рисунок 2 — Массив указателей и три строки в памяти

Размеры матрицы с клавиатуры

Главное преимущество динамической матрицы — её размеры могут быть переменными, известными только во время работы программы. Например, прочитаем матрицу n × m и посчитаем сумму элементов на главной диагонали:

main.cpp
C++
#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;
}
terminal
Bash
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] дважды — сначала к первым скобкам, потом ко вторым:

terminal
Bash
matrix[1][3]
= (*(matrix + 1))[3]
= *(*(matrix + 1) + 3)

Возьмём ту же память, что на схеме выше: в строке 1 лежат числа 777, 65304, −254, 6, 1. Проследим вычисление по шагам:

ВыражениеЗначениеЧто происходит
matrix0x0Адрес начала массива указателей
matrix + 10x8Сдвиг на 1 элемент типа int *, то есть на 8 байт
*(matrix + 1)0x3cСодержимое ячейки 0x8 — адрес начала строки 1. Это всё ещё адрес, а не число!
*(matrix + 1) + 30x48Сдвиг на 3 элемента типа int: 3 · 4 = 12 байт, 0x3c + 0xc = 0x48
*(*(matrix + 1) + 3)6Содержимое ячейки 0x48 — сам элемент
Разбор matrix[1][3]: matrix равен 0x0, matrix + 1 равен 0x8, разыменование даёт адрес строки 0x3c, сдвиг на 3 int даёт адрес 0x48, второе разыменование даёт число 6.
Рисунок 3 — Двойная индексация: два сдвига и два разыменования

Проверим в программе — все три записи выведут одно и то же:

main.cpp
C++
#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;
}
terminal
Bash
6
6
6

Рисовать адреса при решении задач не нужно: там удобнее представлять матрицу как обычную таблицу чисел. Но один раз разобраться, что происходит внутри, полезно — такие вопросы любят задавать на экзаменах в университете, а понимание пригодится, когда дойдём до функций и объектов.

Как освободить память матрицы

Память матрицы освобождается в обратном порядке относительно выделения. Выделяли сначала массив указателей, потом строки — значит, удаляем сначала строки, а потом массив указателей:

main.cpp
C++
for (int i = 0; i < ROWS; i++) {
    delete[] matrix[i];
}
delete[] matrix;

При i = 0 берём из массива указателей адрес 0x28 и передаём его delete[] — строка 0 освобождена. Так же освобождаются строки с адресами 0x3c и 0x60. Последней строкой delete[] matrix освобождаем сам массив указателей по адресу 0x0.

Очистка памяти: правильно — сначала delete[] для строк 0, 1, 2, затем delete[] matrix. Ошибка — сначала delete[] matrix: адреса строк теряются, и освободить строки уже нельзя, возникает утечка памяти.
Рисунок 4 — Порядок освобождения памяти

Посчитаем вызовы: new[] выполнился ROWS + 1 раз — один раз для массива указателей и по разу для каждой строки. Столько же раз должен выполниться delete[].

ВыделениеОсвобождениеСколько раз
matrix[i] = new int[COLS];delete[] matrix[i];ROWS — по разу на строку
int **matrix = new int*[ROWS];delete[] matrix;Один раз, последним

Обмен строк — это обмен указателей

У динамической матрицы есть приятная особенность. Чтобы поменять местами две строки обычной матрицы, нужно поэлементно обменять все m чисел. В динамической матрице строки лежат отдельно, а в массиве указателей хранятся только их адреса — достаточно обменять два указателя:

main.cpp
C++
#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;
}
terminal
Bash
9 2 7 
4 5 6 
3 8 1
Обмен строк 0 и 2 динамической матрицы: до обмена matrix[0] хранит 0x28, а matrix[2] — 0x60. После обмена адреса поменялись местами, сами строки в памяти остались на своих местах.
Рисунок 5 — Обмен строк через обмен указателей

Сами строки при этом не копируются, поэтому обмен выполняется за одно действие при любой длине строки. Эта идея пригодится во второй задаче контеста.

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

ОшибкаЧто происходитКак исправить
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[]

Задачи на динамические матрицы

Закрепите материал в контесте к уроку. В нём пять заданий:

  1. Выделение памяти под матрицу. Выберите фрагмент, который правильно создаёт матрицу rows × cols.
  2. Очистка памяти матрицы. Найдите все фрагменты, которые освобождают память без утечек и неопределённого поведения.
  3. Разыменование и оператор []. Посчитайте, что выведет программа с записями *(*(matrix + 2) + 1), *(matrix[1] + 3) и (*matrix)[2].
  4. Строка большой матрицы. Прочитайте матрицу, в которой может быть до 100 000 строк или до 100 000 столбцов, и выведите её k-ю строку.
  5. Обмен строк с максимумом и минимумом. Найдите строки с максимальным и минимальным элементами и поменяйте их местами — подойдёт идея с обменом указателей.

Решая задачи, рисуйте память: где лежит массив указателей, где — строки, какой адрес хранится в 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++ с нуля с автоматической проверкой задач.

Использованная литература

  1. Рабочий проект стандарта C++: выражение new [Электронный ресурс]. — URL: https://eel.is/c++draft/expr.new (дата обращения: 21.11.2026).
  2. Рабочий проект стандарта C++: выражение delete [Электронный ресурс]. — URL: https://eel.is/c++draft/expr.delete (дата обращения: 21.11.2026).
  3. Рабочий проект стандарта C++: индексирование [Электронный ресурс]. — URL: https://eel.is/c++draft/expr.sub (дата обращения: 21.11.2026).
  4. Рабочий проект стандарта C++: аддитивные операторы [Электронный ресурс]. — URL: https://eel.is/c++draft/expr.add (дата обращения: 21.11.2026).
  5. Выражение new [Электронный ресурс]. — URL: https://en.cppreference.com/w/cpp/language/new (дата обращения: 21.11.2026).
  6. Выражение delete [Электронный ресурс]. — URL: https://en.cppreference.com/w/cpp/language/delete (дата обращения: 21.11.2026).
  7. Встроенный оператор индексирования [Электронный ресурс]. — URL: https://en.cppreference.com/w/cpp/language/operator_member_access (дата обращения: 21.11.2026).