casting de vide ** à int

J’ai un tableau 2D dynamic stocké dans un pointeur void** , et je me demande simplement comment je suis censé transtyper / déréférencer les valeurs pour qu’elles puissent être imprimées?

Voici un exemple de ce que j’essaie de faire:

 /* Assume that I have a data structure called graph with some * element "void** graph" in it and some element "int order" */ void foo(graph_t *graph) { int **masortingx; /*safe malloc works fine, it uses calloc to initialise it all to zeroes*/ masortingx = safe_malloc(graph->order * sizeof(int*)); for (i = 0; i order; i++) masortingx[i] = safe_malloc(graph->order * sizeof(int)); /* storing masortingx in the data structure */ masortingx = (int**)graph->graph; printf("%d\n", (int)graph->graph[2][2]); } 

Lorsque j’essaie de le comstackr, le compilateur me donne l’avertissement suivant: “déréférencement du ‘pointeur’ * vide” et l’erreur: “utilisation non valide de l’expression vide”.

Que dois-je faire pour convertir le pointeur void** afin que je puisse imprimer des éléments à partir de graph->graph ?

MODIFIER:

merci pour l’aide de tous; Je ne peux pas créer de graphe-> graphe de type int ** car il doit contenir plusieurs types de données, le seul que je rencontre des difficultés pour l’implémentation est le tableau int **.

J’ai changé de masortingce = (int * ) graphe-> graphe en graphe-> graphe = (void *) masortingce et cela a bien fonctionné, je suis capable d’imprimer des éléments du tableau, mais maintenant si j’implémente une fonction séparée:

 void print_foo(graph_t *graph) { int i,j; for (i = 0; i order; i++) { for(j = 0; j order; j++) { printf("%d ", ((int**)graph->graph)[i][j]); } putchar('\n'); } } 

cela me donne juste un défaut de segmentation, cependant si je lance ce bloc de code dans le foo original (graph_t * graph), il affiche bien le tableau 2D.

Quelqu’un peut-il s’il vous plaît expliquer ce qui se passe à graphe-> graphe de sorte qu’il ne sera pas imprimer si je l’appelle d’une fonction différente

Donné:

 typedef struct graph_t { int order; void **graph; } graph_t; 

et en supposant que vous graph->graph comme un tableau de int * et une série de tableaux de int , vous pouvez alors, si vous le souhaitez, écrire:

 #include  #include  typedef struct graph_t { int order; void **graph; } graph_t; extern void *safe_malloc(size_t n); extern void foo(graph_t *graph); void foo(graph_t *graph) { int **masortingx; /*safe malloc works fine, it uses calloc to initialise it all to zeroes*/ masortingx = safe_malloc(graph->order * sizeof(int*)); for (int i = 0; i < graph->order; i++) masortingx[i] = safe_malloc(graph->order * sizeof(int)); /* storing masortingx in the data structure */ graph->graph = (void **)masortingx; // Reverse order of assignment // C comstackr complains without the cast - the cast is nasty! printf("%d\n", ((int **)graph->graph)[2][2]); } 

Le code doit vérifier que graph->order >= 3 pour éviter les problèmes de débordement.

Cependant, la structure est assez désagréable et le transtypage nécessaire dans l’instruction printf() suffit à vous faire comprendre pourquoi il est méchant. Vous seriez bien mieux avec un int **graph; dans la structure:

 #include  #include  typedef struct graph_t { int order; int **graph; } graph_t; extern void *safe_malloc(size_t n); extern void foo(graph_t *graph); void foo(graph_t *graph) { int **masortingx; masortingx = safe_malloc(graph->order * sizeof(int*)); for (int i = 0; i < graph->order; i++) masortingx[i] = safe_malloc(graph->order * sizeof(int)); graph->graph = masortingx; printf("%d\n", graph->graph[2][2]); } 

Ces deux éléments sont compilés sans avertissements, même avec des niveaux d’alerte ssortingcts. Aucune des deux n’a été formellement testée en créant une fonction main() pour l’exercer. Vous devez également disposer d’une bar(graph_t *graph) fonctions bar(graph_t *graph) pour libérer la mémoire allouée, bien sûr.