如何从C中的结构成员的指针访问数组中的值

Question

I've searched stackoverflow and seen every combination of the words in my question, but not the question I have.

I have an array of ints, it happens to be a 2d array.

const int themap[something][something] = { {0, ...

I have a struct that I want to have a pointer to this array in my program

typedef struct {
int** mymap;
} THE_STRUCT

In my program I want to iterate over the values of the array through the struct's pointer, but my data seems to be corrupted if i try to access it through the . syntax

int value;
THE_STRUCT mystruct;
mystruct = (int**) themap;

...
//access the map data from mystruct's pointer?
value = mystruct.mymap[x][y];
//doesn't seem to return correct values

Taking the struct out of the picture the same exact function works if I directly use the array (as a global variable)

int value;
...
//access the map directly
value = themap[x][y]
//everyone is happy!

I would like to use the struct as in reality it will carry other information as well as the fact that I will need to be able to assign the pointer to other arrays with different data.

Answer 1

Your two-dimensional array is not the same as an int ** . If you want to store a pointer to it inside the struct , you can do something like:

const int themap[something1][something2] = { {0, ...

typedef struct {
    const int (*mymap)[something2];
} THE_STRUCT;

...

THE_STRUCT my_struct;
my_struct.mymap = themap;

...

int value = my_struct.mymap[x][y];

It is possible to use an int ** , but it requires some effort:

const int themap[something1][something2] = { {0, ...
const int * themapPointerArray[something1] = {themap[0], themap[1], ..., themap[something1 - 1]};

typedef struct {
    const int **mymap;
} THE_STRUCT;

...

THE_STRUCT my_struct;
my_struct.mymap = themapPointerArray;

...

int value = my_struct.mymap[x][y];

Answer 2

A multidimensional array int [][] and a double-indirect pointer int ** are two completely different things.

A multidimensional array is, to C, a one-dimensional array indexed in a different way. Say x is int [3][4] . Then, x contains 12 sequentially-packed elements, and x[1][2] is just the 6th element of that one-dimensional array.

A double-indirect pointer treated as a 2-dimensional array is an array of pointers to arrays . So, if y is int ** , then y[1][2] means "the third element of the array pointed to by the second element of y ".

You cannot therefore convert between int [][] and int ** , since they just represent different things (your casting of int [][] to int ** causes the integers in the int [][] array to be treated as pointers, which will inevitably crash).

Instead, you can cast int [M][N] as int (*)[N] -- a pointer to an array of N -length arrays.