2D Arrays in C: Multidimensional Arrays, Memory Layout, and Matrices

A multidimensional array is an array whose elements are themselves arrays. int grid[3][4]; is not a special grid type - it is three elements, each of which is an array of four ints, stored back to back. Once that clicks, the rest of the topic follows: the layout, the indexing arithmetic, and the otherwise-baffling rule about passing them to functions.

Two dimensions covers almost every practical use - grids, tables, matrices, game boards, images - so that is what this page works with.

Declaring and Initializing

int grid[3][4];        // 3 rows, 4 columns - 12 ints

The first number is how many rows, the second how many columns. Initializers can be written flat or with inner braces; the braces are worth using because they show the shape.

#include <stdio.h>

int main(void) {
    int a[2][3] = {{1, 2, 3}, {4, 5, 6}};   // braced by row - clearest
    int b[2][3] = {1, 2, 3, 4, 5, 6};       // flat - same result
    int c[2][3] = {{1, 2}, {4}};            // partial rows: rest are zero
    int d[2][3] = {0};                      // every element zero
    int e[][3]  = {{1, 2, 3}, {4, 5, 6}};   // rows deduced, columns required

    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;
}

The int e[][3] form matters: you may leave the row count blank and let the initializer decide, but the column count is never optional. The next section explains why.

Row-Major Layout

C stores a 2D array in row-major order: the whole of row 0, then the whole of row 1, and so on, in one unbroken block of memory. There is no array of row-pointers behind the scenes.

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

how you picture it            how it actually sits in memory
+----+----+----+----+
|  1 |  2 |  3 |  4 |   row 0   +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+           | 1| 2| 3| 4| 5| 6| 7| 8| 9|10|11|12|
|  5 |  6 |  7 |  8 |   row 1   +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+            \__ row 0 __/\__ row 1 __/\_ row 2 _/
|  9 | 10 | 11 | 12 |   row 2
+----+----+----+----+           grid[i][j] is at element index i*4 + j

That formula, i * columns + j, is the entire mechanism - and it is why the compiler must know the column count to index anything. The row count never enters the calculation.

You can see the layout directly by printing addresses:

#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]);
        }
    }

    // the same block read as one flat run of 12 ints
    printf("\nflattened: ");
    int *flat = &grid[0][0];
    for (int k = 0; k < 12; k++) {
        printf("%d ", flat[k]);
    }
    printf("\n");

    return 0;
}

The addresses climb by sizeof(int) with no gaps, including where one row ends and the next begins. The flattened loop proves it - flat[k] walks all twelve elements as a single run.

This layout also has a performance consequence worth knowing: looping rows-then-columns touches memory in order, which the CPU cache likes. Swapping the loop nesting so the inner loop steps down a column instead jumps by a whole row each time and can run several times slower on a big array.

Nested Loops

Two dimensions want two for loops: the outer picks the row, the inner sweeps that row's columns.

#include <stdio.h>

#define ROWS 3
#define COLS 4

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

    // fill with a multiplication table
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] = (i + 1) * (j + 1);
        }
    }

    // print it as a table
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }

    // row totals and a grand total
    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;
}

Name the counters after what they mean (i/row for rows, j/col for columns) and keep the order consistent - grid[row][col] everywhere. Half of all 2D-array bugs are a transposed pair of indices.

The #defined sizes are not decoration either: the loop bounds and the declaration now cannot drift apart when you change the shape.

Passing a 2D Array to a Function

Here is the rule that trips everyone: the function's parameter must declare the column count.

#include <stdio.h>

#define COLS 4

// the column size is required; the row count comes as a separate argument
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");
    }
}

// exactly the same parameter, written as the pointer it really is
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;
}

The reason is decay. Passing grid converts it to a pointer to its first element - and its elements are rows, so the type is int (*)[4]: pointer to an array of 4 ints. For grid[i][j] to mean anything, the compiler must know how far one row is, and that is the 4. The row count is genuinely absent from the type, which is why it travels as a separate argument.

Note int (*grid)[COLS] and int grid[][COLS] are the same parameter written two ways - the parentheses are required, since int *grid[COLS] would be an array of pointers instead. That distinction is covered in pointers and arrays.

If the column count is only known at runtime, C99's variably-modified parameters let you pass it first:

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

rows and cols must be declared before the array parameter that uses them. Where that is unavailable, the common alternative is a flat 1D array plus manual index arithmetic:

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

// treat a flat block as rows x cols and do the arithmetic yourself
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] is exactly what the compiler writes for you in the fixed-size case. Doing it by hand costs one line and works for any shape decided at runtime.

A Matrix Example

Matrix multiplication puts the whole page together - three nested loops over row-major storage.

#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);

    // transpose A in place
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {     // start at i+1 to swap each pair once
            int temp = a[i][j];
            a[i][j] = a[j][i];
            a[j][i] = temp;
        }
    }
    print_matrix("A transposed:", a);

    return 0;
}

Two details worth copying. The inner k loop pairs a[i][k] with b[k][j] - one index walks a row, the other walks a column. And the transpose starts its inner loop at j = i + 1: starting at 0 would swap every pair twice and leave the matrix unchanged.

Three Dimensions and Beyond

The pattern extends, and so does the rule about function parameters - every dimension except the first must be declared.

#include <stdio.h>

int main(void) {
    // 2 layers, 3 rows, 4 columns
    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;
}

In practice, three dimensions is where fixed-size arrays start to feel unwieldy, and most code switches to a flat block with computed indices or an array of structs that names what each axis means.

Common Mistakes

• Writing grid[i, j]. The comma operator evaluates i, discards it, and indexes with j. It compiles. It is wrong. Use grid[i][j].
• Transposing the indices. grid[col][row] reads a real element from the wrong place, so there is no error to catch it. Keep the [row][col] order everywhere.
• Omitting the column size in a parameter. void f(int grid[][]) does not compile, and that is the compiler saving you.
• Going out of bounds. As with any array, there is no bounds check. grid[0][5] on a [3][4] grid silently reads grid[1][1], because the layout is contiguous and the arithmetic does not care.