casting void ** alla matrice 2D di int – C

sto provando a lanciare un puntatore vuoto ** a un int ** 2D array in C

ecco il codice con cui sto cercando di lavorare (con tutti i bit estranei rimossi):

\*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; } 

quando lo compilo, funziona bene, ma mi avvisa che la variabile ‘matrix’ è impostata ma non utilizzata. non voglio veramente usare la variabile ad interim matrix perché la funzione dovrebbe solo inizializzare l’array, non inserire nulla in esso; ma se provo a lanciare graph_data direttamente su un int ** quando lo assegno a grafico-> grafico in questo modo:

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

mi dà un compito da avviso di tipo puntatore incompatibile.

non lo sto lanciando correttamente? qualcuno ha qualche suggerimento su come posso farlo funzionare senza la variabile “matrix” intermedia? o se no, cosa posso fare con quella variabile in modo che non mi dica l’avviso che è impostato ma non usato?

Grazie

Il compilatore ha ragione, una serie di matrici (o un puntatore a un array) non è uguale a un puntatore a un puntatore. Pensa a come sarebbero disposti nella memoria:

Una matrice di dimensioni MxN sotto forma di una matrice di matrici:

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

A e la stessa “matrice” sotto forma di puntatore a puntatore:

 + ----------- + ----------- + ----------- + ----- +
 |  matrice [0] |  matrice [1] |  matrice [2] |  ... |
 + ----------- + ----------- + ----------- + ----- +
   |  |  |
   |  |  V
   |  |  + -------------- + -------------- + ----- +
   |  |  |  matrice [2] [0] |  matrice [2] [1] |  ... |
   |  |  + -------------- + -------------- + ----- +
   |  |
   |  V
   |  + -------------- + -------------- + ----- +
   |  |  matrice [1] [0] |  matrice [1] [1] |  ... |
   |  + -------------- + -------------- + ----- +
   |
   V
   + -------------- + -------------- + ----- +
   |  matrice [0] [0] |  matrice [0] [1] |  ... |
   + -------------- + -------------- + ----- +

Non importa se si assegna la dimensione corretta, le due variabili semplicemente sono incompatibili, il che è ciò che il compilatore sta dicendo.