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

J’essaie de lancer un pointeur vide ** sur un tableau int ** 2D en C

Voici le code que j’essaie de travailler (avec tous les bits superflus supprimés):

\*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 (*masortingx)[graph->order]; size_t size = (graph->order * graph->order) * sizeof(int); graph_data = safe_malloc(size); /*safe malloc works fine*/ masortingx = (int(*)[graph->order])graph_data; graph->graph = graph_data; } 

lorsque je comstack cela, cela fonctionne bien, mais me prévient que la variable ‘masortingce’ est définie mais non utilisée. Je ne veux pas vraiment avoir à utiliser la variable de masortingce intermédiaire, car la fonction est simplement supposée initialiser le tableau, sans rien y mettre; mais si j’essaie de convertir graph_data directement en un int ** quand je l’assigie à graph-> graph comme ceci:

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

il me donne une affectation d’avertissement de type pointeur incompatible.

Est-ce que je ne le lance pas correctement? Quelqu’un at-il des suggestions quant à la façon dont je peux le faire fonctionner sans la variable “masortingce” intermédiaire? ou sinon, que puis-je faire avec cette variable pour qu’elle ne me prévienne pas qu’elle est définie mais non utilisée?

Merci

Le compilateur a raison, un tableau de tableaux (ou un pointeur sur un tableau) n’est pas identique à un pointeur sur un pointeur. Il suffit de penser à la manière dont elles seraient mises en mémoire

Une masortingce de taille MxN sous la forme d’un tableau de tableaux:

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

A et la même “masortingce” sous la forme de pointeur à pointeur:

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

Peu importe si vous affectez la taille correcte, les deux variables sont simplement incompatibles, ce que votre compilateur vous dit.