Structure et void* en paramètres

Version imprimable

Bonjour,

J'ai besoin d'une petite explication, pourquoi ma structure (Automate) n'est pas préservé lors du passage par le void *
Je m'y suis sûrement mal prit mais je n'arrive pas a déboguer.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
typedef struct data {
   bool res;
   const Automate* aut;
}Data;
 
void transition_automate_aux(int origine, char lettre, int fin, void* data) {
   Data* d = (Data*) data;
   print_automate(d->aut); /* CRASH ERREUR SEGMENTATION */
}
 
bool meme_langage (const char *expr1, const char* expr2)
{
   Data * data = malloc(sizeof(Data));
   data->aut = malloc(sizeof(Automate));
   bool res;
 
   Automate * aut1 = creer_automate(xxx);
 
   data->aut = aut2;
   print_automate(data->aut); /* CRASH PAS */
   pour_toute_transition(aut1, transition_automate_aux, &data);
   return res;
}

Eh bien, ce n'est qu'un extrait de ton code et rien ne dit que la raison du crash est une impossibilité de reconvertir Data depuis void. A regarder le reste, on se demande ce que tu cherches à faire exactement (on se fait une idée à partir des noms des fonctions et des variables, mais c'est tout).

Par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 bool meme_langage (const char *expr1, const char* expr2) // les arguments ne sont jamais utilisés après { Data * data = malloc(sizeof(Data)); data->aut = malloc(sizeof(Automate)); bool res; Automate * aut1 = creer_automate(xxx); // bon, ce aut1 on ne sait pourquoi il est créé (ni comment et dans quelle mesure) data->aut = aut2; // Ah! aut2? connais pas. Il sort d'où? print_automate(data->aut); /* CRASH PAS */ // ben franchement on se demande comment ça marche :) pour_toute_transition(aut1, transition_automate_aux, &data); // mmm... on a ps le code de pour_toute_transition, et alors passer l'adresse du pointeur data... Why? return res; // qui n'a jamais été initialisé?! }

Oui tu as raison j'ai peut-être un peu trop réduit le code (et en plus je l'ai mal fait xD).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
typedef struct data {
   bool* res;
   const Automate* aut;
}Data;
 
void transition_automate_aux(int origine, char lettre, int fin, void* data) {
   Data* d = (Data*) data;
   print_automate(d->aut); /* CRASH */
 
   bool* test = d->res;
   /* A chaque transition de mon automate je fait un && avec le résultat global des transitions précédentes */
   /* Si jamais une seule transition n'est pas une transition du 2nd automate alors le test final sera false */
   /* J'ai fait cette ligne vite fait, il doit y avoir des pb de syntaxe p-e mais là n'est pas le pb, le pb est au-dessus */
   (*test) = (bool)(test && est_une_transition_de_l_automate(aut, origine, lettre, fin)));
}
 
bool meme_langage (Automate * aut1, Automate * aut2)
{
   Data * data = malloc(sizeof(Data));
   data->aut = malloc(sizeof(Automate));
   data->res = malloc(sizeof(bool));
 
   /* Comparaison des automates */
   data->aut = aut2;
   data->res = true;
   print_automate(data->aut); /* Affichage de test pour l'automate dans la structure (fonctionne) */
 
   /* Cette fonction marche et prend en paramètre l'automate, une fonction quelconque (de type void) */
   /* qui va s'appliquer à toutes les transitions de mon automate, et une structure void * pour passer les paramètres */
   /* de la fonction "transition_automate_aux" ou tout autre valeur (compteur, etc...). Ici je m'en sers pour passer */
   /* un booléen  et l'automate 2 qui me sert pour lors de l'appel de fct "est_une_transition_de_l_automate" */
   pour_toute_transition(aut1, transition_automate_aux, &data); 
 
   return true; /* Tampon */
}

Voilà j'ai refait mon exemple en espérant que ca soit plus clair. Je suis sûr à 99% que les fonctions pour_toute_transition et est_une_transition_de_l_automate fonctionne car cela fait partit d'un projet et elles nous ont été fournies.

22/04/2015, 08h44
stendhal666

Ah c'est mieux comme ça!

Mais un point continue à m'intriguer: pourquoi

Code:

pour_toute_transition(aut1, transition_automate_aux, &data);

et pas:

Code:

pour_toute_transition(aut1, transition_automate_aux, data);

Si c'est ce &data qui est passé à transition_automate_aux, il est normal que ça plante, puisqu'il ne s'agit pas de l'adresse de la structure mais de l'adresse du pointeur vers la structure.

Si c'est voulu, il me semble que nous aurions besoin de l'appel de "pour_toute_transition" pour comprendre quel est ce void* qui ne peut pas être casté en Data*
22/04/2015, 09h52
Halo2550

Ah ben voilà tu as trouvé l'erreur du pseudo-débutant en moi !
Merci beaucoup c'était bien le &. Je suis parti avec une simple variable bool au départ puis je me suis rendu compte que j'avais besoin d'une structure et j'ai laissé le "&" :ptdr:
22/04/2015, 10h31
ternel

Le problème, c'est pas d'être passé à une structure, mais à ce que data est un pointeur de structure.
Tu aurais eu le meme problème avec un pointeur de booléen.

Bonne continuation
22/04/2015, 12h02
Halo2550

Citation:

Envoyé par leternel

Le problème, c'est pas d'être passé à une structure, mais à ce que data est un pointeur de structure.
Tu aurais eu le meme problème avec un pointeur de booléen.

Bonne continuation

Oui mais j'avais juste un

Code:

bool res;

et non un

Code:

bool* res;

d'où le passage par adresse.