How do you dynamically allocate a contiguous 3D array in C?

Question

In C, I want to loop through an array in this order

 for(int z = 0; z < NZ; z++)
    for(int x = 0; x < NX; x++)
       for(int y = 0; y < NY; y++)
           3Darray[x][y][z] = 100;

How do I create this array in such a way that 3Darray[0][1][0] comes right before 3Darray[0][2][0] in memory?

I can get an initialization to work that gives me "z-major" ordering, but I really want a y-major ordering for this 3d array

This is the code I have been trying to use:

char *space;
char ***Arr3D;
int y, z;
ptrdiff_t diff;



space = malloc(X_DIM * Y_DIM * Z_DIM * sizeof(char))

Arr3D = malloc(Z_DIM * sizeof(char **));

for (z = 0; z < Z_DIM; z++)
{
    Arr3D[z] = malloc(Y_DIM * sizeof(char *));

    for (y = 0; y < Y_DIM; y++)
    {
        Arr3D[z][y] = space + (z*(X_DIM * Y_DIM) + y*X_DIM);
    }
}

Answer 1

You can't change the array ordering implicit in the language. The array ordering is standard in C.

If you want to change the way your ordering occurs, just change how you access your array, ie: [x][z][y] instead of [x][y][z].

Answer 2

I think the only way to do this is to write your own wind/unwind functionality on a contiguous datastore. In other words you are going to have to write your own map to calculate the storage position of your values.

If you are trying to make a certain order traversal of your array more efficient, you could always transform the incoming matrix before you put it into the array and then do the transform again when you get it out. C style multi-dimensional arrays are packed order, so the math might get a bit tricky (and is beyond what I can detail out here in the time I have).

Sorry for not having a better answer, but I hope that helps

Answer 3

Using an array of pointers can speed things up, but at the cost of greater complexity. If you're not certain you need the performance, then you might try using a C macro:

#define ARR3D(x,y,z) space[(x) + XDIM*((y) + Y_DIM*(z))]

This assumes that x, y, and z are the innermost, middle, and outermost dimensions, respectively.

Answer 4

Pseudocode:

malloc a chunk of memory big enough for
   the char *** pointer for z,
   the char ** pointers for y, which will get pointed to by zs
   the char * pointers for x, which will get pointed to by ys
   the big block of data that they will, in the end, be pointed to by xs
assign z's, y's, x's so that 
    contiguous blocks from the big block of data are adjacent in the y dimension
    (instead of adjacent in the x dimension, as would be normal)

I have done the single-malloc trick for 2D arrays, simply because of the mental exercise and the added convenience of a single malloc / single free, and it works beautifully (just make sure to get a well-aligned memory chunk). I never thought of using this to subvert memory adjacency.