Declaring pointers to 2D arrays in C++

Question

I'm writing a Conway's game of Life simulator for the Arduino. The Arduino environment is kind-of C++, but with static memory allocation only (no new, no malloc() and no STL.)

class Life {

private:

    uint8_t hue;
    uint8_t currState[WIDTH][HEIGHT];
    uint8_t nextState[WIDTH][HEIGHT];

public:

    void draw() {

        // Update the nextState array with the next generation
        for (int x = 0; x < WIDTH; x++) {
            for (int y = 0; y < HEIGHT; y++) {
                nextState[x][y] = alive(x, y) ? hue++ : 0;
            }
        }

        // Copy nextState into leds array
        for (int x = 0; x < WIDTH; x++) {
            for (int y = 0; y < HEIGHT; y++) {
                pixel(x, y) = CHSV(nextState[x][y], 255, 255);
            }
        }

        // make nextState our new currentState, ready for the next generation
        uint8_t tempState[][] = currState;
        currState = nextState;
        nextState = tempState;
    };

//...

};

I'm getting a compilation error on both the declaration of tempState and the last line:

Array has incomplete element type 'uint8_t []'
Array type 'uint8_t [36][20]' is not assignable

Now, I know that in C/C++, "an array is just a pointer to the first element of the array", but the compiler does not seem to agree. What is the magic declaration that will allow me to alias currState to nextState for the next iteration of my draw() method?

Answer 1

As described in the comments post you can not simply swap arrays in such fasion the article describing what arrays in C++ actually are How do I use arrays in C++?. In order to swap the pointers like you want you should create the two private arrays and the pointers to them.

So for instance:

private: 
    uint8_t array1[WIDTH][HEIGHT];
    uint8_t array2[WIDTH][HEIGHT];
    uint8_t (*nextState)[WIDTH][HEIGHT];
    uint8_t (*prevState)[WIDTH][HEIGHT];

now if you base every operation on the pointers to nextState and prevState you can swap them as you described. Note that it will not work with 2d arrays as they are not the pointers but the types (as described in the reference article).

Answer 2

While it's possible to create and swap two pointers as @cerkiewny has pointed out, I think it's probably simpler and cleaner to put the "update generation" code into a function, and just put in two calls to that function:

update_generation(state1, state2);
update_generation(state2, state1);

You'd write your update_generation something like:

void update_generation(uint8_t gen1[HEIGHT][WIDTH], uint8_t gen2[HEIGHT][WIDTH])

This function would always use gen1 to create gen2. Although the parameter type is silently adjusted to a pointer, you don't have to take that into account--you can still write the code as if you were working directly with a pair of arrays.

In case you care to refer to it, I posted a complete Win32 implementation of John Conway's Game of Life using this approach in a previous answer.

Answer 3

There are couple of ways to declare pointers to 2D arrays in C++. I'll start with an example using a 1D array.

Say you have an array:

int arr[SIZE];

The following are two valid pointers to the array.

int* ip1 = arr;
int (*ip2)[SIZE] = &arr;

Assuming n is a valid index, they can be used with the syntax:

ip1[n] = 10;
*(ip1+n) = 10;
(*ip2)[n] = 10;

Of the three, the first two are exactly how you would be able use arr. You can use:

arr[n] = 10;
*(arr+n) = 10;

You cannot use:

(*arr)[n] = 10;

In that sense, ip1 is a true alias for arr and ip2 is not.

Coming to the 2D arrays you are trying to use, you can define the arrays as:

uint8_t array1[WIDTH][HEIGHT];
uint8_t array2[WIDTH][HEIGHT];

You can define pointers to the arrays as:

uint8_t (*ip1)[HEIGHT] = array1;

or

uint8_t (*ip2)[WIDTH][HEIGHT] = &array1;

However, the first form is more natural. Assuming i and j are valid indices, you can use:

ip1[i][j] = 10;

just like you can use:

array1[i][j] = 10;

You will have to use a slightly different syntactic form to use ip2.

(*ip2)[i][j] = 10;

Hence, I would recommend using the first form of pointers to 2D arrays.

Answer 4

Now, I know that in C/C++, "an array is just a pointer to the first element of the array", but the compiler does not seem to agree.

It is right and you are most assuredly very wrong.

What is the magic declaration that will allow me to alias currState to nextState for the next iteration of my draw() method?

There is none. An array is just that- an array. It cannot be an alias. If you wish to swap the array contents, you'll have to swap each element yourself, or create a separate alias that you can rebind. Conceptually, this operation does not make sense. You cannot alias random things to random other things. This just demonstrates a lack of understanding of what an array is.

Note that this kind of shit is why boost::array was invented. Even if your compiler is too primitive to support boost, it's easy to re-create.

Answer 5

#define WIDTH 10
#define HEIGHT 12

#include <stdint.h>

uint8_t arr1[WIDTH][HEIGHT];
uint8_t arr2[WIDTH][HEIGHT];
uint8_t (*currState)[WIDTH][HEIGHT];
uint8_t (*nextState)[WIDTH][HEIGHT];

void copyArray(uint8_t ar1[WIDTH][HEIGHT], uint8_t ar2[WIDTH][HEIGHT]) {
    uint8_t i,j;
    for (i=0; i<WIDTH; i++) {
        for (j=0; j<HEIGHT; j++) {
            ar1[i][j] = ar2[i][j];
        }
    }
}

int main(void) {
    currState = &arr1;
    nextState = &arr2;

    uint8_t tempState[WIDTH][HEIGHT];

    copyArray(tempState, *currState);
    currState = nextState;
    nextState = &tempState;

    return 0;
}

Answer 6

Actually an array is a fixed pointer to the first element in the array (I think this is known as an L-value). This means your assignments at the end for the tempState, currState and nextState cannot work (as you have discovered).

After declaring space for the 2 2d-arrays, you could then declare pointers to the 2d arrays which you might be able to work in a reasonable way. To use the pointers for indexing into the 2-d array, the compiler would need to be aware of the size of the last dimension(s) of the array.

Answer 7

Its been a while since I've done any C++, even longer since I've used 2-dimensional arrays and raw pointers! But, I believe the correct way is:

uint8_t currState[WIDTH][HEIGHT];
uint8_t (*ptr)[HEIGHT] = currState;

Edit -
My bad, should really have tested it first... the above has been corrected.