Multidimensional Arrays in C - 2D and 3D Arrays

Try it on GfG Practice

A multi-dimensional array in C can be defined as an array that has more than one dimension. Having more than one dimension means that it can grow in multiple directions. Some popular multidimensional arrays include 2D arrays which grows in two dimensions, and 3D arrays which grows in three dimensions.

Syntax

The general form of declaring N-dimensional arrays is shown below:

type arrName[size1][size2]....[sizeN];

• type: Type of data to be stored in the array.
• arrName: Name assigned to the array.
• size1, size2,..., sizeN: Size of each dimension.

Examples:

// Two-dimensional array
int two_d[10][20];

// Three-dimensional array:
int three_d[10][20][30];

Size of Multidimensional Arrays

The total number of elements that can be stored in a multidimensional array can be calculated by multiplying the size of both dimensions. Consider the array arr[10][20]:

• The array int arr[10][20] can store total of (10*20) = 200 elements.

To get the size in bytes, we multiply the size of a single element (in bytes) by the total number of elements in the array.

• The size of array int arr[10][20] = 10 * 20 * 4  = 800 bytes, where the size of int is 4 bytes.

Types of Multidimensional Arrays

In C, there can be many types of arrays depending on their dimensions but two of them are most commonly used:

1. 2D Array - Two Dimensional
2. 3D Array - Three Dimensional

2D Arrays in C

A two-dimensional array or 2D array is the simplest form of the multidimensional array. We can visualize a two-dimensional array as one-dimensional arrays stacked vertically forming a table with 'm' rows and 'n' columns. In C, arrays are 0-indexed, so the row number ranges from 0 to (m-1) and the column number ranges from 0 to (n-1).

Declaration of 2D Array

A 2D array with m rows and n columns can be created as:

type arr_name[m][n];

For example, we can declare a two-dimensional integer array with name 'arr' with 10 rows and 20 columns as:

int arr[10][20];

Initialization of 2D Arrays

We can initialize a 2D array by using a list of values enclosed inside '{ }' and separated by a comma as shown in the example below:

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

or

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

The elements will be stored in the array from left to right and top to bottom. So, the first 4 elements from the left will be filled in the first row, the next 4 elements in the second row, and so on. This is clearly shown in the second syntax where each set of inner braces represents one row.

In list initialization, we can skip specifying the size of the row. The compiler will automatically deduce it in this case. So, the below declaration is valid.

type arr_name[][n] = {...values...};

It is still compulsory to define the number of columns.

Note: The number of elements in initializer list should always be either less than or equal to the total number of elements in the array.

Accessing Elements

An element in two-dimensional array is accessed using row indexes and column indexes inside array subscript operator [].

arr_name[i][j]

2D Array Traversal

Traversal means accessing all the elements of the array one by one. We will use two loops, outer loop to go over each row from top to bottom and the inner loop is used to access each element in the current row from left to right.

for(int i = 0; i < row; i++){
    for(int j = 0; J < col; j++){
        arr[i][j];
    }
}

The below example demonstrates the row-by-row traversal of a 2D array.

#include <stdio.h>

int main() {
  
    // Create and initialize an array with 3 rows
  	// and 2 columns
    int arr[3][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };

    // Print each array element's value
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            printf("arr[%d][%d]: %d    ", i, j, arr[i][j]);
        }
      	printf("\n");
    }
    return 0;
}

arr[0][0]: 0    arr[0][1]: 1    
arr[1][0]: 2    arr[1][1]: 3    
arr[2][0]: 4    arr[2][1]: 5    

How 2D Arrays are Stored in the Memory?

As an array, the elements of the 2D array have to be stored contiguously in memory. As the computers have linear memory addresses, the 2-D arrays must be linearized so as to enable their storage. There are two ways to achieve this:

• Row Major Order: This technique stores the 2D array row after row. It means that the first row is stored first in the memory, then the second row of the array, then the third row, and so on.
• Column Major Column: This technique stores the 2D array column after column. It means that first column is stored first in the memory, then the second column, then the third column, and so on.

This allows the random access to the 2D array elements as the computer need not keep track of the addresses of all the elements of the array. It only tracks of the Base Address (starting address of the very first element) and calculates the addresses of other array elements using the base address.

Passing 2D Arrays to Functions

Passing 2D arrays to functions need a specialized syntax so that the function knows that the data being passed is 2d array. The function signature that takes 2D array as argument is shown below:

3D Array in C

A Three-Dimensional Array or 3D array in C is a collection of two-dimensional arrays. It can be visualized as multiple 2D arrays stacked on top of each other.

Declaration of 3D Array in C

We can declare a 3D array with x 2D arrays each having m rows and n columns using the syntax shown below:

type arr_name[x][m][n];

For example, we can declare 3d array, which is made by 2-2D array and each 2D array have 2 rows and 2 columns:

int arr[2][2][2];

Initialization of 3D Array in C

Initialization in a 3D array is the same as that of 2D arrays. The difference is as the number of dimensions increases so the number of nested braces will also increase.

int arr[2][3][2] = {0, 1, 2, 3, 4, 5, 6, 7 , 8, 9, 10, 11}

or

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

Again, just like the 2D arrays, we can also declare the 3D arrays without specifying the size of the first dimensions if we are using initializer list. The compiler will automatically deduce the size of the first dimension. But we still need to specify the rest of the dimensions.

arr [][2][2] = {...Values...};

Accessing Elements

To access elements in 3D array, we use three indexes. One for depth, one for row and one for column inside subscript operator [].

arr_name[d][i][j]

where, d, i and j are the indexes for depth (representing a specific 2D array.), the row within that 2D array, and the column within that 2D array respectively.

3D Array Traversal

To traverse the entire 3D array, you need to use three nested loops: an outer loop that goes through the depth (or the set of 2D arrays), a middle loop goes through the rows of each 2D array and at last an inner loop goes through each element of the current row.

for(int d = 0; d < depth; d++){
    for(int i = 0; i < row; i++){
        for(int j = 0; j < col; j++){
            arr[d][i][j];
        }
    }
}

Let's take a simple example to demonstrate all the concepts we discussed about 3D arrays:

#include <stdio.h>

int main() {
  
    // Create and Initialize the 
    // 3-dimensional array
    int arr[2][3][2] = { { { 1, 1 }, { 2, 3 }, 
                       { 4, 5 } }, { { 6, 7 }, 
                       { 8, 9 }, { 10, 11 } } };

  	// Loop through the depth
    for (int i = 0; i < 2; ++i) {
      
      	// Loop through the 
      	// rows of each depth
        for (int j = 0; j < 3; ++j) {
          
          	// Loop through the 
          	// columns of each row
            for (int k = 0; k < 2; ++k)
                printf("arr[%i][%i][%i] = %d   ", i, j, k,
                       arr[i][j][k]);
          	printf("\n");
        }
      printf("\n\n");
    }
    return 0;
}

arr[0][0][0] = 1   arr[0][0][1] = 1   
arr[0][1][0] = 2   arr[0][1][1] = 3   
arr[0][2][0] = 4   arr[0][2][1] = 5   


arr[1][0][0] = 6   arr[1][0][1] = 7   
arr[1][1][0] = 8   arr[1][1][1] = 9   
arr[1][2][0] = 10   arr[1][2][1] = 11   

How 3D Arrays are Stored in the Memory?

Like 2D arrays, the elements of a 3D array should also be stored contiguously in memory.

Since computers have linear memory, the 3D array must also be linearized for storage. We use the same two techniques, the Row Major Order and Column Major Order but with added dimension. The elements are first stored layer by layer (or 2D array by 2D array). Within each 2D array, the elements follow the corresponding row or column major order.

Passing 3D Arrays to Functions

Passing a 3D array to a function in C is similar to passing 2D arrays, but with an additional dimension. When passing a 3D array, you need to pass the sizes of all the dimensions separately because the size information of array is lost while passing.

kartik

Follow

Improve

Article Tags :

• C Language
• C++
• c-array
• cpp-array
• C-Arrays

+1 More

Practice Tags :

• CPP