How do multidimensional arrays in C++ function? [duplicate]

Answer 1

Multi-dimensional arrays in C and C++ are arrays of arrays. But since an array simply lays out its objects in memory one after the other, an array of arrays just lays out the arrays one after the other. So you can treat it like a single array if you decay it into a pointer.

You initialize an array by putting its values between curly braces, delimited by commas. You initialize an array of arrays the same way - by putting its values (themselves arrays) in braces.

So:

 int line[2][2]={
                  { 100, 100 }, // line[0]
                  { 200, 200 }  // line[1]
                };

There are no shortcuts for assignment though. You have to do it member-by-member (or use some function like memcpy).

Answer 2

The brace-list initializer only works during initialization, and it cannot be used for assignment, as you seem to attempt.

Instead, just initialize the multi-dimensional array all at once:

int line[2][2] = { {100, 100}, {200, 200} };

In response to your first sentence: Arrays are arrays and pointers are pointers, and they're not the same thing. An array does however decay to a pointer to the first element with ease, and x[n] is equivalent to *(x + n). This applies recursively to multi-dimensional arrays as well.

Arrays T[N] are contiguous in memory for T and sizeof(T[N]) == N * sizeof(T); therefore, arrays of arrays T[N][M] are contiguous both for T[N] and for T.

Answer 3

It's been a while since I last coded something on C++ (more of a Java person now) but if I remember correctly multidimensional arrays are indeed arrays of arrays.

And you can initialize array this way: int line[2][2] = {{100, 100}, {200, 200}};

P.S.: square brakes are just simplification: a[x] is the same as *(a+x) and a[x][y] is the same as *(*(a+x)+y)

P.P.S.: slightly corrected initialization

Answer 4

To put it simply, is a multidimensional array in C++ an array of arrays or is it simply a single array which behaves like it's multidimensional?

It is the latter. There is a huge difference in both the memory representation and in how indices are interpreted between multidimensional and ragged arrays.

A multidimensional array such as int array[L][M][N] occupies a contiguous chunk of memory. Accessing an individual element array[i][j][k] is equivalent to *(&array[0][0][0]+(i*M+j)*N+k). The lookup involves but one pointer dereference.

A ragged array such as int *** ragged is a one dimensional array of int** pointers. Each of those int** pointers is a one dimensional array of int* pointers, and each of those is a one dimensional array of ints. Here array[i][j][k] is equivalent to *(*(*(array+i)+j)+k). The lookup involves three pointer dereferences.