How are 3D arrays stored in C?

Question

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?

Answer 1

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] 

Answer 2

All "dimensions" are stored consecutively in memory.

Consider

    int arr[4][100][20]; 

you can say that arr[1] and arr[2] (of type int[100][20]) are contiguous
or that arr[1][42] and arr[1][43] (of type int[20]) are contiguous
or that arr[1][42][7] and arr[1][42][8] (of type int) are contiguous