casting void** to 2D array of int - C

Question

i am trying to cast a void** pointer to an int** 2D array in C

here is the code that i am trying to work with (with all the extraneous bits removed):

\*assume that i have a data structure called graph with some 
 *element "void** graph" in it and some element "int order" */

void initialise_graph_data(graph_t *graph)
{
    void **graph_data = NULL;
    int (*matrix)[graph->order];
    size_t size = (graph->order * graph->order) * sizeof(int);

    graph_data = safe_malloc(size); /*safe malloc works fine*/
    matrix = (int(*)[graph->order])graph_data;
    graph->graph = graph_data;
}

when i compile that, it works fine, but gives me a warning that variable 'matrix' is set but not used. i dont really want to have to use the interim matrix variable because the function is just supposed to initialise the array, not put anything in it; but if i try to cast graph_data directly to an int** when i am assiging it to graph->graph like so:

graph->graph = (int(*)[graph->order])graph_data;

it gives me an assignment from incompatible pointer type warning.

am i just not casting it properly? does anyone have any suggestions as to how i can make it work without the interim "matrix" variable? or if not, what i can do with that variable so that it doesnt give me the warning that it is set but not used?

thanks

Answer 1

The compiler is right, an array of arrays (or a pointer to an array) is not the same as a pointer to a pointer. Just think about how they would be laid out in memory:

A matrix of size MxN in the form of an array of arrays:

+--------------+--------------+-----+----------------+--------------+-----+------------------+
| matrix[0][0] | matrix[0][1] | ... | matrix[0][N-1] | matrix[1][0] | ... | matrix[M-1][N-1] |
+--------------+--------------+-----+----------------+--------------+-----+------------------+

A and the same "matrix" in the form of pointer to pointer:

+--------+     +-----------+-----------+-----------+-----+
| matrix | --> | matrix[0] | matrix[1] | matrix[2] | ... |
+--------+     +-----------+-----------+-----------+-----+
                 |           |           |
                 |           |           V
                 |           |           +--------------+--------------+-----+
                 |           |           | matrix[2][0] | matrix[2][1] | ... |
                 |           |           +--------------+--------------+-----+
                 |           |
                 |           V
                 |           +--------------+--------------+-----+
                 |           | matrix[1][0] | matrix[1][1] | ... |
                 |           +--------------+--------------+-----+
                 |
                 V
                 +--------------+--------------+-----+
                 | matrix[0][0] | matrix[0][1] | ... |
                 +--------------+--------------+-----+

It doesn't matter if you allocate the correct size, the two variables simply are incompatible which is what your compiler is telling you.