C++ Multi-dimensional Arrays

---

---

Multidimensional Array

C++ multidimensional array is an array that has more than one dimension and allows you to store data in a grid-like structure. You can create arrays with multiple dimensions, but here we will discuss two-dimensional (2D) and three-dimensional (3D) arrays.

C++ allows multidimensional arrays. Here is the general form of a multidimensional array declaration −

Syntax

Here is the given syntax for a Multidimensional array in C++:

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

Example

For example, the following declaration creates a three dimensional 5 . 10 . 4 integer array −

int threedim[5][10][4];

Two-Dimensional Arrays

The simplest form of the multidimensional array is the two-dimensional array. A two-dimensional array is, in essence, a list of one-dimensional arrays. To declare a two-dimensional integer array of size x, and y, you would write something as follows −

type arrayName [ x ][ y ];

Where type can be any valid C++ data type and arrayName will be a valid C++ identifier.

A two-dimensional array can be thought of as a table, which will have x number of rows and y number of columns. A 2-dimensional array a, which contains three rows and four columns can be shown below −

Thus, every element in array a is identified by an element name of the form a[ i ][ j ], where a is the name of the array, and i and j are the subscripts that uniquely identify each element in a.

Initializing Two-Dimensional Arrays

Multidimensional arrays may be initialized by specifying bracketed values for each row. Following is an array with 3 rows and each row has 4 columns.

int a[3][4] = {  
   {0, 1, 2, 3} ,   /*  initializers for row indexed by 0 */
   {4, 5, 6, 7} ,   /*  initializers for row indexed by 1 */
   {8, 9, 10, 11}   /*  initializers for row indexed by 2 */
};

The nested braces, which indicate the intended row, are optional. The following initialization is equivalent to the previous example −

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

Accessing Two-Dimensional Array Elements

An element in the 2-dimensional array is accessed by using the subscripts, i.e., row index and column index of the array. For example −

int val = a[2][3];

The above statement will take the 4^th element from the 3^rd row of the array. You can verify it in the above diagram.

#include <iostream>
using namespace std;
 
int main () {
   // an array with 5 rows and 2 columns.
   int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
 
   // output each array element's value                      
   for ( int i = 0; i < 5; i++ )
      for ( int j = 0; j < 2; j++ ) {
      
         cout << "a[" << i << "][" << j << "]: ";
         cout << a[i][j]<< endl;
      }
 
   return 0;
}

When the above code is compiled and executed, it produces the following result −

a[0][0]: 0
a[0][1]: 0
a[1][0]: 1
a[1][1]: 2
a[2][0]: 2
a[2][1]: 4
a[3][0]: 3
a[3][1]: 6
a[4][0]: 4
a[4][1]: 8

As explained above, you can have arrays with any number of dimensions, although it is likely that most of the arrays you create will be of one or two dimensions.

Three-Dimensional Arrays

Similarly, A three-dimensional (3D) array in C++ is an extension of the two-dimensional array concept to add another dimension. Which gives you access to store data in a three-dimensional space. you can visualize it as a cube where each element is identified by three indices which typically denote the dimensions in terms of depth, rows, and columns. To declare a two-dimensional integer array of size x, y and z you would write something as follows −

type arrayName [ x ][ y ][z];

Where type can be any valid C++ data type and arrayName will be a valid C++ identifier.

A three-dimensional array can be thought of as a collection of two-dimensional tables stacked on top of each other, forming a cube-like structure.

Thus, every element in array a is identified by an element name of the form b[ i ][ j ][k], where a is the name of the array, and i, j, and k are the subscripts that uniquely identify each element in b.

Initializing Three-Dimensional Array

A three-dimensional array can be initialized by specifying bracketed values for each layer, row, and column. Following is an example of a 3D array with 2 layers, 3 rows, and 4 columns.

int b[2][3][4] = {  
  {  
    {0, 1, 2, 3},   /* Initializers for layer 0, row 0 */
    {4, 5, 6, 7},   /* Initializers for layer 0, row 1 */
    {8, 9, 10, 11}  /* Initializers for layer 0, row 2 */
  },
  {  
    {12, 13, 14, 15}, /* Initializers for layer 1, row 0 */
    {16, 17, 18, 19}, /* Initializers for layer 1, row 1 */
    {20, 21, 22, 23}  /* Initializers for layer 1, row 2 */
  }
};

In this initialization, the nested braces are used for the intended layer and row for each set of values.

Flat Initialization

Alternatively, you can also initialize a three-dimensional array without nested braces. This method involves the array as a single contiguous block of values. This is the following example:

int b[2][3][4] = {0, 1, 2, 3, 
  4, 5, 6, 7, 
  8, 9, 10, 11, 
  12, 13, 14, 15, 
  16, 17, 18, 19, 
  20, 21, 22, 23};

In this case, the values are listed in a flat format. Both methods of initialization are valid and produce the same array structure.

Accessing Three-Dimensional Array Elements

An element in the 3-dimensional array is accessed by using three subscripts, i.e., the layer index, the row index, and the column index. For example −

int val = b[1][2][3];

In this above statement, val will take the 4^th element from the 3rd row in the 2nd layer of the array b.

Here's given how the indexing works:

• The first index (1) specifies the layer (or depth) of the array.
• The second index (2) specifies the row within that layer.
• The third index (3) specifies the column within that row.

Thus, the element accessed by b[1][2][3] corresponds to the value located in the 1^st layer, 2^nd row, and 3^rd column of the array. You can visualize this by considering how the data is structured in a cube format in which each coordinate points to a specific element within that 3D space.

Example

Here's a given code for this:

#include <iostream>
using namespace std;

int main() {
  // An array with 2 layers, 3 rows, and 4 columns.
  int b[2][3][4] = {{
                        {0, 1, 2, 3},   // Layer 0, Row 0
                        {4, 5, 6, 7},   // Layer 0, Row 1
                        {8, 9, 10, 11}  // Layer 0, Row 2
                    },
                    {
                        {12, 13, 14, 15},  // Layer 1, Row 0
                        {16, 17, 18, 19},  // Layer 1, Row 1
                        {20, 21, 22, 23}   // Layer 1, Row 2
                    }};

  // Output each array element's value
  for (int i = 0; i < 2; i++) {      // Iterating through layers
    for (int j = 0; j < 3; j++) {    // Iterating through rows
      for (int k = 0; k < 4; k++) {  // Iterating through columns
        cout << "b[" << i << "][" << j << "][" << k << "]: ";
        cout << b[i][j][k] << endl;
      }
    }
  }

  return 0;
}

When the above code is compiled and executed, it produces the following result −

b[0][0][0]: 0
b[0][0][1]: 1
b[0][0][2]: 2
b[0][0][3]: 3
b[0][1][0]: 4
b[0][1][1]: 5
b[0][1][2]: 6
b[0][1][3]: 7
b[0][2][0]: 8
b[0][2][1]: 9
b[0][2][2]: 10
b[0][2][3]: 11
b[1][0][0]: 12
b[1][0][1]: 13
b[1][0][2]: 14
b[1][0][3]: 15
b[1][1][0]: 16
b[1][1][1]: 17
b[1][1][2]: 18
b[1][1][3]: 19
b[1][2][0]: 20
b[1][2][1]: 21
b[1][2][2]: 22
b[1][2][3]: 23

The above code effectively demonstrates how to work with three-dimensional arrays in C++.