2d array in C | Initialisation and Program

2D Array in C: Initialization and Practical Guide

In C programming, arrays can have multiple dimensions. A multidimensional array is essentially an array of arrays.

The general syntax for declaring a multidimensional array is:

data_type array_name[size1][size2]...[sizeN];

For example, the following declaration creates a three-dimensional array of integers:

int multidimension[5][10][4];

The simplest and most commonly used form of a multidimensional array is the two-dimensional (2D) array.

What is a Two-Dimensional (2D) Array?

A two-dimensional array is a collection of elements organized in a grid of rows and columns, similar to a table or a mathematical matrix. Structurally, it is a list of one-dimensional arrays.

Syntax

data_type array_name[rows][columns];

• data_type: Any valid C data type (e.g., int, char, float).
• array_name: A valid C identifier.
• rows: The number of rows in the grid.
• columns: The number of columns in each row.

Common Applications

2D arrays are widely used in computer science and software development for:

• Solving mathematical matrix problems.
• Image processing (where pixels are represented as a grid).
• Game boards (like Chess, Tic-Tac-Toe, or Sudoku).
• Storing tabular data and database records.

Accessing 2D Array Elements

To understand how elements are organized and accessed, let's look at a real-world analogy.

Imagine a restaurant menu with 3 categories (Starters, Main Course, and Desserts). Under each category, there are 3 items.

• The food categories represent the rows ($r$).
• The items under each category represent the columns ($c$).

We can represent this menu structure as a $3 \times 3$ matrix named A:

| Rows | Column 0 ($c = 0$) | Column 1 ($c = 1$) | Column 2 ($c = 2$) | | :--- | :--- | :--- | :--- | | Row 0 (Starters) | A[0][0] | A[0][1] | A[0][2] | | Row 1 (Main Course) | A[1][0] | A[1][1] | A[1][2] | | Row 2 (Desserts) | A[2][0] | A[2][1] | A[2][2] |

Indexing Rule

In C, array indices always start at 0. To access a specific element, you must specify both the row index and the column index using separate square brackets:

array_name[row_index][column_index]

⚠️ Common Pitfall: Do not use comma-separated indices like A[r, c]. In C, this uses the comma operator and will not work as expected. Always use separate brackets: A[r][c].

Initialization of 2D Arrays

You can initialize a 2D array at the time of declaration in several ways.

1. Row-by-Row Initialization (Recommended)

This method uses nested braces to group elements by row. It is highly readable because it visually mirrors the structure of a matrix.

int a[2][3] = {  
    {1, 3, 1},  /* Row 0 initialization */
    {4, 5, 6}   /* Row 1 initialization */
};

2. Flat Initialization

Since C stores 2D arrays in contiguous memory locations (row-major order), you can list all elements sequentially without nested braces:

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

While this is functionally identical to the first method, it is generally less readable for larger arrays.

Rules for Omitting Dimensions

When initializing a 2D array, you can omit the row dimension, but you must always specify the column dimension.

Here are some examples of valid and invalid declarations:

int a[2][2] = {1, 2, 3, 4};   /* Valid: Both dimensions specified */
int a[][2]  = {1, 2, 3, 4};   /* Valid: Row size is omitted, compiler infers it as 2 */

int abc[][]   = {1, 2, 3, 4}; /* Invalid: Column size must be specified */
int abc[2][]  = {1, 2, 3, 4}; /* Invalid: Column size must be specified */

Why is the Column Size Mandatory?

In C, a 2D array is stored in memory as a continuous linear sequence of elements. To locate a specific element like a[i][j], the compiler performs pointer arithmetic using the formula:

$$\text{Address of } a[i][j] = \text{Base Address} + \big(i \times \text{number_of_columns} + j\big) \times \text{sizeof(data_type)}$$

Without knowing the number of columns, the compiler cannot calculate the memory offset to transition from one row to the next. Therefore, the column size is strictly required.