I understand that arrays in C are allocated in row-major order. Therefore, for a 2 x 3 array:
0 1
2 3
4 5
Is stored in memory as
0 1 2 3 4 5
However, what if I have a 2 x 3 x 2 array:
0 1
2 3
4 5
and
6 7
8 9
10 11
How are these stored in memory? Is just consecutive like:
0 1 2 3 4 5 6 7 8 9 10 11
Or is it some other way? Or does it depend on something?
At a low level, there is no such thing as a multi-dimensional array. There is just a flat block of memory, large enough to hold a given number of elements. In C, a multi-dimensional array is conceptually an array whose elements are also arrays. So if you do:
int array[2][3];
Conceptually you end up with:
array[0] => [0, 1, 2]
array[1] => [0, 1, 2]
This results in the elements being arranged contiguously in memory, because array[0]
and array[1]
are not actually holding any data, they are just references to the two inner arrays. Note that this means that only the [0, 1, 2]
entries actually occupy space in memory. If you extend this pattern out to the next dimension, you can see that:
int array[2][3][2];
...will give you a structure like:
array[0] => [0] => [0, 1]
[1] => [0, 1]
[2] => [0, 1]
array[1] => [0] => [0, 1]
[1] => [0, 1]
[2] => [0, 1]
Which continues arranging the elements consecutively in memory (as above, only the [0, 1]
entries actually occupy space in memory, everything else is just part of a reference to one of these entries). As you can see, this pattern will continue no matter how many dimensions you have.
And just for fun:
int array[2][3][2][5];
Gives you:
array[0] => [0] => [0] => [0, 1, 2, 3, 4]
[1] => [0, 1, 2, 3, 4]
[1] => [0] => [0, 1, 2, 3, 4]
[1] => [0, 1, 2, 3, 4]
[2] => [0] => [0, 1, 2, 3, 4]
[1] => [0, 1, 2, 3, 4]
array[1] => [0] => [0] => [0, 1, 2, 3, 4]
[1] => [0, 1, 2, 3, 4]
[1] => [0] => [0, 1, 2, 3, 4]
[1] => [0, 1, 2, 3, 4]
[2] => [0] => [0, 1, 2, 3, 4]
[1] => [0, 1, 2, 3, 4]