C の 2 次元配列：多次元配列、メモリ配置、行列

多次元配列とは、要素そのものが配列である配列のことです。int grid[3][4]; は特別なグリッド型ではありません。4 個の int からなる配列が 3 つ、隙間なく並んでいるだけです。これが腑に落ちれば、残りの話題は自然についてきます。配置、インデックスの計算、そして一見不可解な「関数に渡すときのルール」です。

実用的な用途のほとんどは 2 次元で足ります。グリッド、テーブル、行列、ゲーム盤、画像などです。そこで本ページも 2 次元を軸に進めます。

宣言と初期化

int grid[3][4];        // 3 行 4 列 - int が 12 個

最初の数値が行数、2 つ目が列数です。初期化子はフラットにも内側の波かっこ付きでも書けますが、形が見えるので波かっこを使う価値があります。

#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] の形は重要です。行数は空欄にして初期化子に決めさせられますが、列数は決して省略できません。その理由は次の節で説明します。

行優先（row-major）配置

C は 2 次元配列を行優先順で格納します。行 0 の全体、次に行 1 の全体……と、途切れのない 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("element addresses, in memory order:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("grid[%d][%d] = %2d at %p\n", i, j, grid[i][j], (void *)&grid[i][j]);
        }
    }

    // 同じブロックを 12 個の int の平坦な並びとして読む
    printf("\nflattened: ");
    int *flat = &grid[0][0];
    for (int k = 0; k < 12; k++) {
        printf("%d ", flat[k]);
    }
    printf("\n");

    return 0;
}

アドレスは sizeof(int) ずつ、ある行の終わりと次の行の始まりのところも含めて隙間なく増えていきます。平坦化したループがそれを証明しています。flat[k] は 12 個すべての要素を 1 つの連なりとして歩きます。

この配置には知っておく価値のある性能上の帰結もあります。行を外側、列を内側にしてループするとメモリを順番に触るので、CPU キャッシュに好かれます。ループの入れ子を逆にして内側で列方向に下っていくと、毎回 1 行分ジャンプすることになり、大きな配列では数倍遅くなることがあります。

ネストしたループ

2 次元には 2 つの 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("\nrow totals: ");
    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("\ngrand total: %d\n", grand);

    return 0;
}

カウンタには意味の分かる名前を付け（行には i/row、列には j/col）、順序はどこでも grid[row][col] に揃えましょう。2 次元配列のバグの半分は、添字を入れ替えてしまったものです。

#define したサイズも飾りではありません。これでループの範囲と宣言が、形を変えたときにずれてしまうことがなくなります。

2 次元配列を関数に渡す

ここが誰もがつまずくルールです。関数の仮引数は列数を宣言しなければなりません。

#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("\nafter scaling:\n");
    print_grid(grid, 3);

    return 0;
}

理由は減衰（decay）です。grid を渡すと、その先頭要素へのポインタに変換されます。そして要素は行なので、型は int (*)[4]、すなわち 4 個の int の配列へのポインタになります。grid[i][j] が意味を持つには、コンパイラが 1 行分の距離を知っていなければならず、それがこの 4 です。行数は本当に型に含まれていないので、別の引数として運ばれます。

int (*grid)[COLS] と int grid[][COLS] は同じ仮引数の 2 通りの書き方であることに注意してください。かっこは必須です。int *grid[COLS] だとポインタの配列になってしまいます。その違いは ポインタと配列 で扱います。

列数が実行時にしか分からない場合、C99 の可変修飾仮引数を使えば先に渡せます。

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

rows と cols は、それらを使う配列仮引数より前に宣言しなければなりません。これが使えない場合の一般的な代替は、平坦な 1 次元配列と手計算の添字演算です。

#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] は、サイズ固定の場合にコンパイラが代わりに書いてくれるものそのものです。手で書いても 1 行で済み、実行時に決まるどんな形にも対応できます。

行列の例

行列の掛け算はこのページの内容をすべて結びつけます。行優先の記憶領域に対する 3 重のネストループです。

#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++) {     // 各ペアを 1 回だけ入れ替えるため i+1 から始める
            int temp = a[i][j];
            a[i][j] = a[j][i];
            a[j][i] = temp;
        }
    }
    print_matrix("A transposed:", a);

    return 0;
}

まねする価値のある点が 2 つあります。内側の k ループは a[i][k] と b[k][j] を組み合わせます。片方の添字が行を歩き、もう片方が列を歩きます。そして転置は内側のループを j = i + 1 から始めます。0 から始めるとすべてのペアを 2 回入れ替えてしまい、行列は元のままになります。

3 次元、そしてその先

このパターンは拡張できますし、関数仮引数のルールも同様です。最初の次元を除くすべての次元を宣言しなければなりません。

#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("layer %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("\ntotal elements: %zu\n", sizeof cube / sizeof cube[0][0][0]);
    return 0;
}

実務では、3 次元あたりからサイズ固定の配列は扱いづらく感じられ始め、多くのコードは添字を計算する平坦なブロックか、各軸の意味に名前を付けた 構造体 の配列へ切り替えます。

よくある間違い

• grid[i, j] と書く。 カンマ演算子は i を評価して捨て、j で添字付けします。コンパイルは通ります。しかし間違いです。grid[i][j] を使いましょう。
• 添字を入れ替える。 grid[col][row] は間違った場所から本物の要素を読むので、捕まえてくれるエラーがありません。どこでも [row][col] の順序を保ちましょう。
• 仮引数で列サイズを省く。 void f(int grid[][]) はコンパイルできません。そしてそれはコンパイラがあなたを救っているのです。
• 範囲外に出る。 ほかの 配列 と同じく、境界チェックはありません。[3][4] のグリッドで grid[0][5] は黙って grid[1][1] を読みます。配置が連続していて、計算はそんなことを気にしないからです。