Learn C++

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


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:


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:


int anArray[3][5] =
{
{ 1, 2, 3, 4, 5, }, // row 0
{ 6, 7, 8, 9, 10, }, // row 1
{ 11, 12, 13, 14, 15 } // row 2
};

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:


int anArray[][5] =
{
{ 1, 2, 3, 4, 5, },
{ 6, 7, 8, 9, 10, },
{ 11, 12, 13, 14, 15 }
};

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


int anArray[][] =
{
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 }
};

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:


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.


for (int nRow = 0; nRow < nNumRows; nRow++)
    for (int nCol = 0; nCol < nNumCols; nCol++)
        cout << anArray[nRow][nCol];

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


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:


// Declare a 10x10 array
const int nNumRows = 10;
const int nNumCols = 10;
int nProduct[nNumRows ][nNumCols ] = { 0 };

// Calculate a multiplication table
for (int nRow = 0; nRow < nNumRows; nRow++)
    for (int nCol = 0; nCol < nNumCols; nCol++)
        nProduct[nRow][nCol] = nRow * nCol;

// Print the table
for (int nRow = 1; nRow < nNumRows; nRow++)
{
    for (int nCol = 1; nCol < nNumCols; nCol++)
        cout << nProduct[nRow][nCol] << "\t";

    cout << endl;
}

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

6.6 — C-style strings