Introduction to Multi-dimensional Arrays

Multi-dimensional arrays

A multi-dimensional array can be seen as an “array of arrays.”

A $d$-dimensional array is an array of $d-1$-dimensional arrays, in which we can use nested braces to group the different levels of elements.

The most commonly used multi-dimensional array is a 2-D (two-dimensional) array. It can be visualized as an array of single-dimensional arrays. Let’s see how to make it in C++.

Creating a two-dimensional array

A 2-D array can be represented as rows and columns. The following syntax is used to declare a 2-D array.

DataType array_name[row_size][column_size];

For example:

int TwoDArray[4][3]; 

Here, a 2-D array named TwoDArray is being declared with 4 rows and 3 columns. It can be visualized as an array having 4 elements and each element is a single dimension array of size 3; so in total, it contains 12 values.

The TwoDArray array may be viewed logically as the following:

Initializing a 2-D array

A 2-D array can be initialized in a number of ways.

Using nested braces

Since a 2-D array is an array of 1-D arrays, we can use nested curly braces to group the different levels of elements.

For instance, in the example below, we have a 2-D array of 5 rows and 3 columns. We can see five elements inside the outer curly braces, which can be viewed as rows. Each of these row elements contains three elements that can be viewed as the columns that are being initialized.

int TwoDArray[5][3] = { {0,1,2}, {1,6,4}, {2,9,5}, {3,9,6}, {4,9,4}};

Initializing within a single pair of braces

Can you guess how the arrays will be initialized with the following expression?

int TwoDArray[3][2]={42, 81, 72};

Here, the first three indices of the 2-D array will be initialized with 42, 81, and 72, while the remaining three indices will be initialized with 0. So the first row will be {42, 81}, the second row will be {72, 0}, and the third row will be {0,0}.

Though this expression does not have the nested curly braces for the different dimensions, the initialization using this expression is also valid.

This is possible because the compiler stores a multi-dimensional array in the form of a 1-D array at the backend.

As long as the number of values does not exceed the size of the array, all values are assigned in the increasing subscript of the last dimension by the compiler. We will be able to understand this better when we see how array elements can be accessed in the lesson below.

Initializing with zeros

Like in a one-dimensional array, when we don’t explicitly initialize the array or write anything within the braces, the elements are initialized with 0s. For example:

int TwoDArray[5][3] = { {0,1,2}, {1, 6}, {2}, {3,9,6}, {} };

Here, the second row’s third column will be initialized to 0, and the third row’s second and third columns will also be initialized to 0. In the fifth row, all three columns will be initialized to 0.

In short, the elements not explicitly initialized are initialized to zero.

What about the following expression?

int TwoDArray[5][3] = { {0}, {1}, {2}, {3}, {4} };

Here, the first column of every row will be initialized to 0, 1, 2, 3, and 4, respectively. The rest will all be initialized to 0.

Click “Run” to see the output of this example.

Explicitly initializing certain elements

Like in a simple array, we can also explicitly initialize certain indices. For example, in the TwoDArray matrix, we can initialize the following indices like this:

int TwoDArray[4][3]={};// this will initialize the entire array with value = 0
// second row, third column
TwoDArray[1][2] = 3;
// first row, first column
TwoDArray[0][0] = 9;

The matrix will be initialized as in the image shown below.

Based on the TwoDArray matrix shown in the image above, solve the quiz below.

Below are some example programs based on what we learned above. Let’s run all programs one by one to see the outputs.

Initializing a 2-D array with user input

Below is a program that takes numbers as input from the user to initialize two matrices, adds the result inside a new matrix, and prints the result.

Accessing and mapping functions

Though we represent a 2-D array in terms of rows and columns, a multidimensional array is practically stored like a 1-D array. So the memory allocation is linear.

Say we have a 2-D array with $n$ rows and $4$ columns; then, at the back end, this array will be stored in the form of a 1-D array with a total of $n * 4$ locations (based on the array data type).

Let’s see how multi-dimensional arrays are mapped to a single-dimensional array. There are two ways to map the elements:

• Row major mapping
• Column major mapping

Since C++ follows the row-major layout, let’s look at row-major mapping.

The general formula that the compiler uses is:

baseAddress + $r_i$ * cols + $c_{i}$

Where baseAddress is the address of the array, cols is the number of columns of the array, and $c_i$ and $r_i$ are the rows and column indices, respectively, of the element that we want to access or initialize.

Say we wanted to access the element at [1][2], which is $2$ in the arr array.

The compiler does this via the following steps:

1. Take the base address of array arr.

2. Take the product of the row index ri with the number of columns, i.e. cols which is equal to ri*cols (e.g. for ri=1, it will be $1 * 4 = 4$). This is like skipping $r_i$ rows.

3. Add the outcome to the column index $c_i$ i.e. (4 + 2 = 6).

4. Multiply the result by the size of the data type (which is 4 bytes for integers), i.e. $6 * 4 = 24$, which is equivalent to 0x0018 in hexadecimal.

5. Finally, add the above result to the array base address (arr + 0x0018)

Since the base address is 0xb0, so 0xb0 + 0x0018 = 0xc8, which is exactly where value 5 is in our arrays.