Исполняемые доки C: многомерные массивы

Q: Как объявить двумерный массив в C?

Укажите два размера в квадратных скобках: int grid[3][4]; объявляет 3 строки по 4 столбца - всего 12 значений int. Читайте это как «массив из 3 элементов, каждый из которых - массив из 4 значений int», потому что именно так C его и хранит.

Q: Как передать двумерный массив в функцию в C?

Параметр обязан объявлять число столбцов: void print(int grid[][4], int rows) или эквивалентно void print(int (*grid)[4], int rows). Число строк можно опустить, потому что массив приводится к указателю на строку, - но без размера столбца компилятор не сможет вычислить, где начинается строка.

Q: Можно ли обнулить весь двумерный массив при инициализации?

Да: int grid[3][4] = {0}; обнуляет каждый элемент, потому что всё, что вы не перечислили, инициализируется нулём. int grid[3][4] = {{1, 2}}; задаёт первые два элемента строки 0, а остальные десять оставляет нулевыми.

Многомерный массив - это массив, элементы которого сами являются массивами. int grid[3][4]; - не какой-то особый тип «сетка», а три элемента, каждый из которых является массивом из четырёх значений int, лежащих подряд. Как только это укладывается в голове, остальное следует само: размещение в памяти, арифметика индексов и в остальном необъяснимое правило про передачу в функции.

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

Объявление и инициализация

int grid[3][4];        // 3 строки, 4 столбца - 12 значений int

Первое число - сколько строк, второе - сколько столбцов. Инициализаторы можно писать плоским списком или с внутренними фигурными скобками; скобки стоит использовать, потому что они показывают форму.

#include <stdio.h>

int main(void) {
    int a[2][3] = {{1, 2, 3}, {4, 5, 6}};   // скобки по строкам - нагляднее всего
    int b[2][3] = {1, 2, 3, 4, 5, 6};       // плоско - результат тот же
    int c[2][3] = {{1, 2}, {4}};            // неполные строки: остальное нули
    int d[2][3] = {0};                      // все элементы нулевые
    int e[][3]  = {{1, 2, 3}, {4, 5, 6}};   // строки выведены, столбцы обязательны

    printf("a: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", a[i][j]);
    printf("\nb: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", b[i][j]);
    printf("\nc: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", c[i][j]);
    printf("\nd: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", d[i][j]);
    printf("\ne: "); for (int i = 0; i < 2; i++) for (int j = 0; j < 3; j++) printf("%d ", e[i][j]);
    printf("\n");

    return 0;
}

Форма int e[][3] важна: число строк можно оставить пустым и позволить инициализатору его определить, а вот число столбцов не опционально никогда. Почему - в следующем разделе.

Построчное размещение

C хранит двумерный массив в построчном порядке (row-major): целиком строка 0, затем целиком строка 1 и так далее, одним сплошным блоком памяти. Никакого скрытого массива указателей на строки за кулисами нет.

int grid[3][4] = {{ 1, 2, 3, 4},
                  { 5, 6, 7, 8},
                  { 9,10,11,12}};

как вы это представляете       как это лежит в памяти на самом деле
+----+----+----+----+
|  1 |  2 |  3 |  4 |  строка 0  +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+            | 1| 2| 3| 4| 5| 6| 7| 8| 9|10|11|12|
|  5 |  6 |  7 |  8 |  строка 1  +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+             \_ строка 0 _/\_ строка 1 _/\_ стр 2 _/
|  9 | 10 | 11 | 12 |  строка 2
+----+----+----+----+            grid[i][j] имеет индекс элемента i*4 + j

Эта формула, i * число_столбцов + j, и есть весь механизм - и именно поэтому компилятор обязан знать число столбцов, чтобы вообще что-либо проиндексировать. Число строк в вычисление не входит никогда.

Размещение можно увидеть напрямую, напечатав адреса:

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    printf("адреса элементов в порядке размещения:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("grid[%d][%d] = %2d по адресу %p\n", i, j, grid[i][j], (void *)&grid[i][j]);
        }
    }

    // тот же блок, прочитанный как один плоский ряд из 12 значений int
    printf("\nплоско: ");
    int *flat = &grid[0][0];
    for (int k = 0; k < 12; k++) {
        printf("%d ", flat[k]);
    }
    printf("\n");

    return 0;
}

Адреса растут на sizeof(int) без пропусков, в том числе там, где одна строка заканчивается и начинается следующая. Плоский цикл это доказывает: flat[k] проходит все двенадцать элементов как единый ряд.

У такого размещения есть и следствие для производительности, о котором стоит знать: перебор «строки, затем столбцы» обращается к памяти по порядку, что нравится кэшу процессора. Поменяйте вложенность так, чтобы внутренний цикл шёл вниз по столбцу, - и каждый шаг будет прыгать через целую строку, а на большом массиве это может оказаться в несколько раз медленнее.

Вложенные циклы

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

#include <stdio.h>

#define ROWS 3
#define COLS 4

int main(void) {
    int grid[ROWS][COLS];

    // заполняем таблицей умножения
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] = (i + 1) * (j + 1);
        }
    }

    // печатаем как таблицу
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }

    // суммы по строкам и общая сумма
    int grand = 0;
    printf("\nсуммы строк: ");
    for (int i = 0; i < ROWS; i++) {
        int rowSum = 0;
        for (int j = 0; j < COLS; j++) {
            rowSum += grid[i][j];
        }
        grand += rowSum;
        printf("%d ", rowSum);
    }
    printf("\nобщая сумма: %d\n", grand);

    return 0;
}

Называйте счётчики по смыслу (i/row для строк, j/col для столбцов) и соблюдайте порядок - везде grid[row][col]. Половина всех багов с двумерными массивами - это переставленная местами пара индексов.

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

Передача двумерного массива в функцию

Вот правило, на котором спотыкаются все: параметр функции обязан объявлять число столбцов.

#include <stdio.h>

#define COLS 4

// размер столбца обязателен; число строк приходит отдельным аргументом
void print_grid(int grid[][COLS], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }
}

// ровно тот же параметр, записанный как указатель, которым он и является
void scale_grid(int (*grid)[COLS], int rows, int factor) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] *= factor;
        }
    }
}

int main(void) {
    int grid[3][COLS] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    print_grid(grid, 3);
    scale_grid(grid, 3, 10);
    printf("\nпосле умножения:\n");
    print_grid(grid, 3);

    return 0;
}

Причина - приведение (decay). Передача grid превращает его в указатель на первый элемент, а элементы у него - строки, поэтому тип получается int (*)[4]: указатель на массив из 4 значений int. Чтобы grid[i][j] вообще что-то означало, компилятор должен знать, какова длина одной строки, и это как раз та самая 4. Число строк в типе действительно отсутствует, поэтому оно и путешествует отдельным аргументом.

Обратите внимание: int (*grid)[COLS] и int grid[][COLS] - один и тот же параметр, записанный двумя способами; скобки обязательны, потому что int *grid[COLS] был бы массивом указателей. Это различие разобрано в указателях и массивах.

Если число столбцов известно только во время выполнения, переменно-модифицируемые параметры из C99 позволяют передать его первым:

void print_any(int rows, int cols, int grid[rows][cols]);

rows и cols должны быть объявлены раньше, чем использующий их параметр-массив. Там, где это недоступно, обычной альтернативой служит плоский одномерный массив с ручной арифметикой индексов:

#include <stdio.h>
#include <stdlib.h>

// трактуем плоский блок как rows x cols и считаем индексы сами
void print_flat(const int *data, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%4d", data[i * cols + j]);
        }
        printf("\n");
    }
}

int main(void) {
    int rows = 2, cols = 5;

    int *data = malloc((size_t)rows * cols * sizeof *data);
    if (data == NULL) return 1;

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            data[i * cols + j] = i * 10 + j;
        }
    }

    print_flat(data, rows, cols);
    free(data);
    return 0;
}

data[i * cols + j] - в точности то, что компилятор пишет за вас в случае фиксированного размера. Сделать это руками стоит одной строки и работает для любой формы, определяемой во время выполнения.

Пример с матрицами

Умножение матриц собирает всю страницу воедино - три вложенных цикла поверх построчного хранения.

#include <stdio.h>

#define N 3

void multiply(const int a[][N], const int b[][N], int out[][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            int total = 0;
            for (int k = 0; k < N; k++) {
                total += a[i][k] * b[k][j];
            }
            out[i][j] = total;
        }
    }
}

void print_matrix(const char *label, const int m[][N]) {
    printf("%s\n", label);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%5d", m[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main(void) {
    int a[N][N] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int b[N][N] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int product[N][N] = {0};

    print_matrix("A:", a);
    print_matrix("B:", b);

    multiply(a, b, product);
    print_matrix("A x B:", product);

    // транспонируем A на месте
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {     // начинаем с i+1, чтобы менять каждую пару один раз
            int temp = a[i][j];
            a[i][j] = a[j][i];
            a[j][i] = temp;
        }
    }
    print_matrix("A транспонированная:", a);

    return 0;
}

Две детали, которые стоит перенять. Внутренний цикл по k соединяет a[i][k] с b[k][j] - один индекс идёт по строке, другой по столбцу. А транспонирование начинает внутренний цикл с j = i + 1: начав с 0, вы поменяли бы каждую пару дважды и оставили матрицу неизменной.

Три измерения и дальше

Схема расширяется, и правило про параметры функций тоже: каждое измерение, кроме первого, должно быть объявлено.

#include <stdio.h>

int main(void) {
    // 2 слоя, 3 строки, 4 столбца
    int cube[2][3][4] = {0};

    for (int z = 0; z < 2; z++) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                cube[z][i][j] = z * 100 + i * 10 + j;
            }
        }
    }

    for (int z = 0; z < 2; z++) {
        printf("слой %d:\n", z);
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                printf("%5d", cube[z][i][j]);
            }
            printf("\n");
        }
    }

    printf("\nвсего элементов: %zu\n", sizeof cube / sizeof cube[0][0][0]);
    return 0;
}

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

Частые ошибки

Запись grid[i, j]. Оператор «запятая» вычисляет i, отбрасывает результат и индексирует по j. Это компилируется. Это неверно. Пишите grid[i][j].
Перестановка индексов. grid[col][row] читает настоящий элемент, но не оттуда, откуда нужно, так что никакой ошибки, которая бы это поймала, не будет. Держите порядок [row][col] везде.
Пропуск размера столбца в параметре. void f(int grid[][]) не компилируется, и это компилятор вас спасает.
Выход за границы. Как и у любого массива, проверки границ здесь нет. grid[0][5] на сетке [3][4] молча прочитает grid[1][1], потому что данные лежат непрерывно, а арифметике всё равно.

Часто задаваемые вопросы

Как объявить двумерный массив в C?

Укажите два размера в квадратных скобках: int grid[3][4]; объявляет 3 строки по 4 столбца - всего 12 значений int. Читайте это как «массив из 3 элементов, каждый из которых - массив из 4 значений int», потому что именно так C его и хранит.

Как двумерный массив хранится в памяти в C?

В построчном порядке (row-major): сначала все элементы строки 0, затем все элементы строки 1 и так далее, одним непрерывным блоком. grid[i][j] лежит со смещением i * число_столбцов + j элементов от начала - вот почему компилятору нужно именно число столбцов.

Как передать двумерный массив в функцию в C?

Параметр обязан объявлять число столбцов: void print(int grid[][4], int rows) или эквивалентно void print(int (*grid)[4], int rows). Число строк можно опустить, потому что массив приводится к указателю на строку, - но без размера столбца компилятор не сможет вычислить, где начинается строка.

Можно ли обнулить весь двумерный массив при инициализации?

Да: int grid[3][4] = {0}; обнуляет каждый элемент, потому что всё, что вы не перечислили, инициализируется нулём. int grid[3][4] = {{1, 2}}; задаёт первые два элемента строки 0, а остальные десять оставляет нулевыми.

Связанные концепции