A 2D Array Is an Array of Arrays

When you write int grid[3][4]; you are telling the compiler: “give me 3 items, and each item is itself an array of 4 integers”. That makes 12 integers in total. The first index picks the row, the second index picks the column inside that row.

The important detail for embedded C programming is memory layout. C stores a 2D array in row-major order: the whole of row 0 comes first, then the whole of row 1, and so on. There is no gap between rows and no hidden pointer table. The picture below shows grid[3][4] as the programmer sees it and as memory sees it.

Read the second diagram top to bottom as one long line of memory. Element grid[r][c] sits at position r * 4 + c from the start. Remember this formula, because it explains the most important rule of this lecture.

Full 2D Array Initialization in C with Nested Braces

The clearest way to initialize a 2D array is one inner brace pair per row:

int m[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

The outer braces hold the rows, each inner pair holds the columns of that row. This style is self-documenting: anyone reading it can see the table shape immediately, which is why firmware teams prefer it for keymaps and lookup tables.

Flat initialization (legal, but harder to read)

C also lets you drop the inner braces. The values are then poured into the array in row-major order until they run out:

int m[2][3] = {1, 2, 3, 4, 5, 6};   /* same table as above */
int n[2][3] = {1, 2, 3, 4};         /* row 0 = 1 2 3, row 1 = 4 0 0 */

The second line shows the risk: with flat braces a single missing value shifts everything after it. Use nested braces and you cannot make that mistake.

Partial Initialization Fills the Rest with Zero

If you supply fewer values than the array has elements, the remaining elements are set to zero. This applies per row when you use nested braces. Here is a complete program you can compile yourself.

/* init2d.c - partial initialization and automatic row count */
#include <stdio.h>

int main(void)
{
    /* Partial initialization: missing values become 0 */
    int grid[3][4] = {
        {7},
        {1, 2},
        {9, 8, 6}
    };

    /* First dimension left blank: compiler counts the rows */
    int table[][3] = {
        {10, 20, 30},
        {40},
        {50, 60},
        {70, 80, 90}
    };

    int rows = sizeof(table) / sizeof(table[0]);

    printf("grid:\n");
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++)
            printf("%4d", grid[r][c]);
        printf("\n");
    }

    printf("table has %d rows\n", rows);
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < 3; c++)
            printf("%4d", table[r][c]);
        printf("\n");
    }
    return 0;
}

Build and run it:

$ gcc -std=c11 -Wall -Wextra -o init2d init2d.c
$ ./init2d
grid:
   7   0   0   0
   1   2   0   0
   9   8   6   0
table has 4 rows
  10  20  30
  40   0   0
  50  60   0
  70  80  90

Notice how each inner brace pair is independent. Row 0 of grid received only the value 7, so its other three columns are zero, and that does not disturb the next row. If you want an entire array zeroed, the shortest form is int z[4][4] = {0}; because the first element gets 0 and every other element is zero-filled automatically.

Why the Second Dimension Is Always Required

You may leave the first dimension blank and let the compiler count the rows from your initializer list, as table[][3] did above. You may never leave the second dimension blank. The reason is the address formula we saw earlier.

To find table[i][j] the generated code computes base + (i * COLS + j) * sizeof(int). The number of rows never appears. Without COLS the compiler has no idea where row 1 starts. Try it and gcc tells you exactly that:

int bad[][] = { {1, 2}, {3, 4} };

$ gcc -std=c11 bad.c
bad.c:4:9: error: array type has incomplete element type 'int[]'
bad.c:4:9: note: declaration of 'bad' as multidimensional array
                 must have bounds for all dimensions except the first

Counting rows automatically with sizeof

When the row count is left blank, you often still need it in a loop. The standard trick divides the size of the whole array by the size of one row:

int rows = sizeof(table) / sizeof(table[0]);   /* 4 in our program */
int cols = sizeof(table[0]) / sizeof(table[0][0]);   /* 3 */

This stays correct if you later add or remove a row from the initializer list, which is why it is a best practice in embedded C programming. Remember it works only where the array is still an array, not after it has been passed to a function and decayed to a pointer.

Designated Initializers for Sparse Tables (C99)

Modern C lets you name the exact element you want to set. Everything you do not name is zero. This is perfect for sparse tables such as an identity matrix or a keypad map where only a few cells matter:

int ident[3][3] = {
    [0][0] = 1,
    [1][1] = 1,
    [2][2] = 1
};

The result is the 3×3 identity matrix: ones on the diagonal and zeros everywhere else. Designated initializers need a C99 or newer compiler, which every current embedded toolchain provides.

Real-World Use: Constant Tables in Firmware

On a microcontroller, a 2D array marked const at file scope is normally placed in read-only memory (flash) instead of precious RAM. That makes it ideal for data that never changes:

static const unsigned char keymap[4][4] = {
    {'1', '2', '3', 'A'},
    {'4', '5', '6', 'B'},
    {'7', '8', '9', 'C'},
    {'*', '0', '#', 'D'}
};

A 4×4 keypad driver scans row and column lines and then simply returns keymap[row][col]. No if-else chain, no switch, just an index into a table. The same pattern appears in LED matrix fonts, ADC calibration grids and state-machine transition tables. Check your toolchain’s map file to confirm where the table landed, because placement rules differ between compilers and linker scripts.

Common Mistakes and Troubleshooting

Best Practices

• Use nested braces so each row is visible in the source.
• Give dimensions names with #define or enum, for example ROWS and COLS, instead of bare numbers.
• Mark read-only tables const so they stay out of RAM on small devices.
• Compute the row count with sizeof when you leave the first dimension blank.
• Compile with -Wall -Wextra so excess initializers and unused values are reported.
• Large 2D arrays declared as locals consume stack. On a small MCU prefer static or global storage.

Summary and Key Takeaways

• A 2D array is stored row-major as one continuous block.
• Missing initializers become zero, row by row, when nested braces are used.
• The first dimension is optional with an initializer list; the second is mandatory because it is the row stride.
• sizeof(array) / sizeof(array[0]) gives the row count.
• Designated initializers set individual cells and zero the rest.
• const 2D tables are the standard way to store fixed data in embedded C programming.

Conclusion

Once you understand that a 2D array is just a long line of memory with a row stride, initialization rules stop feeling like trivia and start making sense. You know why braces matter, why zeros appear, and why the compiler insists on the column count. In the next lectures of this free embedded C course we put these tables to work by adding, multiplying and transposing matrices.

Frequently Asked Questions