Multidimensional Arrays

The elements of an array can be of any data type, including arrays! An array of arrays is called a multidimensional array.

1	int anArray[3][5]; // a 3-element array of 5-element arrays

In this case, since we have 2 subscripts, this is a two-dimensional array. In a two-dimensional array, it is convenient to think of the first subscript as being the row, and the 2nd subscript as being the column. Conceptually, the above two-dimensional array is laid out as follows:

[0][0]  [0][1]  [0][2]  [0][3]  [0][4]
[1][0]  [1][1]  [1][2]  [1][3]  [1][4]
[2][0]  [2][1]  [2][2]  [2][3]  [2][4]

To access the elements of a two-dimensional array, simply use two subscripts:

1	anArray[2][3] = 7;

To initialize a two-dimensional array, it is easiest to use nested braces, with each set of numbers representing a row:

1	int anArray[3][5] =

2

{

3	{ 1, 2, 3, 4, 5, }, // row 0

4	{ 6, 7, 8, 9, 10, }, // row 1

5	{ 11, 12, 13, 14, 15 } // row 2

6

};

When the C++ compiler processes this list, it actually ignores the inner braces altogether. However, we highly recommend you use them anyway for readability purposes.
Two-dimensional arrays with initializer lists can omit (only) the first size specification:

1	int anArray[][5] =

2

{

3	{ 1, 2, 3, 4, 5, },

4	{ 6, 7, 8, 9, 10, },

5	{ 11, 12, 13, 14, 15 }

6

};

The compiler can do the math to figure out what the array size is. However, the following is not allowed:

1	int anArray[][] =

2

{

3	{ 1, 2, 3, 4 },

4	{ 5, 6, 7, 8 }

5

};

Because the inner parenthesis are ignored, the compiler can not tell whether you intend to declare a 1×8, 2×4, 4×2, or 8×1 array in this case.
Just like normal arrays, multidimensional arrays can still be initialized to 0 as follows:

1	int anArray[3][5] = { 0 };

Note that this only works if you explicitly declare the size of the array! Otherwise, you will get a two-dimensional array with 1 row.
Accessing all of the elements of a two-dimensional array requires two loops: one for the row, and one for the column. Since two-dimensional arrays are typically accessed row by row, generally the row index is used as the outer loop.

1	for (int nRow = 0; nRow < nNumRows; nRow++)

2	for (int nCol = 0; nCol < nNumCols; nCol++)

3	cout << anArray[nRow][nCol];

Multidimensional arrays may be larger than two dimensions. Here is a declaration of a three-dimensional array:

1	int anArray[5][4][3];

Three-dimensional arrays are hard to initialize in any kind of intuitive way using initializer lists, so it’s typically better to initialize the array to 0 and explicitly assign values using nested loops.
Let’s take a look at a practical example of a two-dimensional array:

01	// Declare a 10x10 array

02	const int nNumRows = 10;

03	const int nNumCols = 10;

04	int nProduct[nNumRows ][nNumCols ] = { 0 };

05

06	// Calculate a multiplication table

07	for (int nRow = 0; nRow < nNumRows; nRow++)

08	for (int nCol = 0; nCol < nNumCols; nCol++)

09	nProduct[nRow][nCol] = nRow * nCol;

10

11	// Print the table

12	for (int nRow = 1; nRow < nNumRows; nRow++)

13

{

14	for (int nCol = 1; nCol < nNumCols; nCol++)

15	cout << nProduct[nRow][nCol] << "\t";

16

17	cout << endl;

18

}

This program calculates and prints a multiplication table for all values between 1 and 9 (inclusive). Note that when printing the table, the for loops start from 1 instead of 0. This is to omit printing the 0 column and 0 row, which would just be a bunch of 0s! Here is the output:

1    2    3    4    5    6    7    8    9
2    4    6    8    10   12   14   16   18
3    6    9    12   15   18   21   24   27
4    8    12   16   20   24   28   32   36
5    10   15   20   25   30   35   40   45
6    12   18   24   30   36   42   48   54
7    14   21   28   35   42   49   56   63
8    16   24   32   40   48   56   64   72
9    18   27   36   45   54   63   72   81