Allocate 6xNxN array

Question

I have a variable N. I need a 6xNxN array.

Something like this:

int arr[6][N][N];

But, obviously, that doesn't work.

I'm not sure how I'd go about allocating this so that I can access, e.g. arr[5][4][4] if N is 5, and arr[5][23][23] if N is 24.

Note that N will never change, so I'll never have to reallocate arr.

What should I do? Will int ***arr = malloc(6 * N * N * sizeof(int)); work?

Answer 1

You can allocate your 3-dimensional array on the heap as

int (*arr)[N][N] = malloc(sizeof(int[6][N][N]));

After use, you can free as

free(arr);

Another way of writing the same as suggested by @StoryTeller is -

int (*arr)[N][N] = malloc(6u * sizeof(*arr));

But here you need to be careful about the u after 6 to prevent signed arithmetic overflow.

Also, there can still be issues on platforms where size_t is smaller in width that int as suggested by @chqrlie, but that won't be the case on "most" commonly used platforms and hence you are fine using it.

Answer 2

int arr[6][N][N]; will work just fine. You merely need to update your compiler and C knowledge to the year 1999 or later, when variable-length arrays (VLA) were introduced to the language.

(If you have an older version of GCC than 5.0, you must explicitly tell it to not use an ancient version of the C standard, by passing -std=c99 or -std=c11.)

Alternatively if you need heap allocation, you can do:

int (*arrptr)[Y][Z] = malloc( sizeof(int[X][Y][Z]) );

You cannot do int ***arr = malloc(6 * N * N * sizeof(int)); since a int*** cannot point at a 3D array. In general, more than two levels of indirection is a certain sign that your program design is completely flawed.

Detailed info here: Correctly allocating multi-dimensional arrays.

Answer 3

What you want can't work directly. For indexing a multi-dimensional array, all but the very first dimension need to be part of the type and here's why:

The indexing operator operates on pointers by first adding an index to the pointer and then dereferencing it. The identifier of an array evaluates to a pointer to its first element (except when e.g. used with sizeof, _Alignof and &), so indexing on arrays works as you would expect.

It's very simple in the case of a single-dimension array. With

int a[42];

a evaluates to a pointer of type int * and indexing works the following way: a[18] => *(a + 18).

Now in a 2-dimensional array, all the elements are stored contiguously ("row" after "row" if you want to understand it as a matrix), and what's making the indexing "magic" work is the types involved. Take for example:

int a[16][42];

Here, the elements of a have the type int ()[42] (42-element array of int). According to the rules above, evaluating an expression of this type in most contexts again yields an int * pointer. But what about a itself? Well, it's an array of int ()[42] so a will evaluate to a pointer to 42-element array of int: int (*)[42]. Then let's have a look at what the indexing operator does:

a[3][18] => *(*(a + 3) + 18)

With a evaluating to the address of a with type int (*)[42], this inner addition of 3 can properly add 42 * sizeof(int). This would be impossible if the second dimension wasn't known in the type.

I guess it's simple to deduce the example for the n-dimensional case.

---

In your case, you have two possibilities to achieve something similar to what you want.

1. Use a dynamically allocated flat array with size 6*N*N. You can calculate the indices yourself if you save N somewhere.

2. Somewhat less efficient, but yielding better readable code, you could use an array of pointers to arrays of pointers to int (multiple indirection). You could e.g. do

   int ***a = malloc(6 * sizeof *int);
   for (size_t i = 0; i < 6; ++i)
   {
       a[i] = malloc(N * sizeof *(a[i]));
       for (size_t j = 0; j < N ++j)
       {
           a[i][j] = malloc(N* sizeof *(a[i][j]));
       }
   }
   // add error checking to malloc calls!
   

   Then your accesses will look just like those to a normal 3d array, but it's stored internally as many arrays with pointers to the other arrays instead of in a big contiguous block.

   I don't think it's worth using this many indirections, just to avoid writing e.g. a[2*N*N+5*N+4] to access the element at 2,5,4, so my recommendation would be the first method.

Answer 4

Making a simple change to the declaration on this line and keeping the malloc can easily solve your problem.

int ***arr = malloc(6 * N * N * sizeof(int));

However, int *** is unnecessary (and wrong). Use a flat array, which is easy to allocate:

int *flatarr = malloc(6 * N * N * sizeof(int));

This works for three dimensions, and instead of accessing arr[X][Y][Z] as in the question, you access flatarr[(X*N*N) + (Y*N) + Z]. In fact, you could even write a handy macro:

#define arr(X,Y,Z) flatarr[((X)*N*N) + ((Y)*N) + (Z)]

This is basically what I've done in my language Cubically to allow for multiple-size cubes. Thanks to Programming Puzzles & Code Golf user Dennis for giving me this idea.