Discussion :

[Obofix le gaulois]

Bonjour.

J’ai une erreur de segmentation en utilisant la fonction free que je ne parviens pas à comprendre.
L’erreur disparaît si je supprime l’instruction free(self->states);
J’ai épuré le code pour ne garder que les éléments liés à l’erreur.

Mon output est précisément
Coucou 1
Coucou 2
Erreur de segmentation (core dumped)

Quelqu’un comprend-t-il mon erreur?

Merci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
36
37
38
39
40
41
42
43
44
 
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//#include "fa.h"
 
 
struct fa
{
	struct state *states; //Tableau des états composant l'automate	
};
 
 
struct state
{
	//Chaque état, peut être final et/ou initial
	bool is_initial;
	bool is_final;
};
 
 
void fa_create(struct fa *self, size_t alpha_count, size_t state_count)
{
	self = malloc(sizeof(struct fa*));
	self->states = calloc(state_count, sizeof(struct state*));	
}
 
 
void fa_destroy(struct fa *self)
{
	free(self->states); // L'erreur disparait si je commente cela...
	free(self);
}
 
 
int main()
{
struct fa *autom=NULL;
printf("Coucou 1 \n");
fa_create(autom, 3, 5);
printf("Coucou 2 \n");
fa_destroy(autom);
printf("Coucou 3 \n");
}

[Obsidian]

Bonjour,

Ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void fa_create(struct fa *self, size_t alpha_count, size_t state_count)
{
	self = malloc(sizeof(struct fa*));
	self->states = calloc(state_count, sizeof(struct state*));	
}

Tu alloues suffisamment d'espace non pas pour une structure fa (reférencée par un « pointeur sur une structure fa » que tu as ici nommé self) mais pour un « pointeur sur une structure fa », soit 4 ou 8 octets uniquement.

Quand tu l'exploites, tu fais un dépassement de segment mais comme tout cela reste à l'intérieur du segment alloué à ton processus, le micro-processeur ne déclenche pas de segfault. Il reste que tu corromps sans le savoir tes données adjacentes, et le crash se produit a posteriori, au moment de libérer la mémoire.

[Obofix le gaulois]

Effectivement vous avez raison.

En revanche je dois avoir une autre erreur car même en retirant l’étoile de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

self = malloc(sizeof(struct fa*));

j’ai de toujours une erreur de segmentation...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
36
37
38
39
40
41
42
43
44
 
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//#include "fa.h"
 
struct fa
{
	struct state *states; //Tableau des états composant l'automate	
};
 
 
struct state
{
	//Chaque état, peut être final et/ou initial
	bool is_initial;
	bool is_final;
};
 
 
void fa_create(struct fa *self, size_t alpha_count, size_t state_count)
{
	self = malloc(sizeof(struct fa));
	self->states = calloc(state_count, sizeof(struct state*));	
}
 
 
void fa_destroy(struct fa *self)
{
	free(self->states); // L'erreur disparait si je commente cela...
	free(self);
}
 
 
 
int main()
{
struct fa *autom=NULL;
printf("Coucou 1 \n");
fa_create(autom, 3, 5);
printf("Coucou 2 \n");
fa_destroy(autom);
printf("Coucou 3 \n");
}

[Médinoc]

Bonjour,
Il y a deux problèmes.

1. Même erreur sur states.
   Sinon plutôt que faire un sizeof du type, tu peux utiliser l'écriture alternative "sizeof du type pointé":
   

   Code C :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   3
   4
   5
   void fa_create(struct fa *self, size_t alpha_count, size_t state_count)
   {
   	self = malloc(sizeof(*self));
   	self->states = calloc(state_count, sizeof(self->states[0]));	
   }

2. Ton appel de fonction est incorrect: Ta fonction est censée modifier le pointeur self, mais ne reçoit en paramètre qu'une copie de celle-ci. Pour corriger ça, soit tu retourne la variable:
   

   Code C :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   3
   4
   5
   6
   struct fa * fa_create(size_t alpha_count, size_t state_count)
   {
   	struct fa * self = malloc(sizeof(*self));
   	self->states = calloc(state_count, sizeof(self->states[0]));	
   	return self;
   }

   Soit tu utilises un pointeur de pointeur:
   

   Code C :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   3
   4
   5
   6
   void fa_create(struct fa **ppself, size_t alpha_count, size_t state_count)
   {
   	struct fa *self = malloc(sizeof(*self));
   	*self->states = calloc(state_count, sizeof(self->states[0]));	
   	*ppself = self;
   }

   N'oublie pas de modifier l'appel en conséquence.

[Sve@r]

Bonjour

Pour corriger ça, soit tu retourne la variable:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void fa_create(size_t alpha_count, size_t state_count)
{
	struct fa * self = malloc(sizeof(*self));
	self->states = calloc(state_count, sizeof(self->states[0]));	
	return self;
}

et ne pas oublier de faire correspondre le type de la fonction en conséquence...

[Médinoc]

OK, c'est corrigé.

[Obofix le gaulois]

[*]Ton appel de fonction est incorrect: Ta fonction est censée modifier le pointeur self, mais ne reçoit en paramètre qu'une copie de celle-ci. Pour corriger ça, soit tu retourne la variable:

Je viens de comprendre que calloc modifie la valeur du pointeur.

Dans ma tête calloc «affectait de la mémoire au pointeur mais sans le modifier». Ce qui n’a probablement aucun sens. Les choses sont plus claires maintenant.

Merci à tous les répondants. :-)

[Sve@r]

Je viens de comprendre que calloc modifie la valeur du pointeur.

Là je ne suis pas certain de bien comprendre. calloc ne peut en aucun cas modifier la valeur du pointeur (duquel d'ailleurs puisque cette fonction ne reçoit pas de pointeur en paramètre !!!!!!!)
calloc alloue une zone mémoire et remplit cette zone de zéros. Ce n'est pas exactement la même chose...

Dans ma tête calloc «affectait de la mémoire au pointeur mais sans le modifier». Ce qui n’a probablement aucun sens.

Idem. calloc n'affecte rien à personne. C'est comme si, dans le code suivant...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int carre(int n) {
    return n*n;
}
 
int main()
{
    int x=carre(5);
}

...tu disais "carre affecte une valeur à x" ; ce qui est totalement faux.

calloc alloue de la mémoire, la remplit de zéros et renvoie l'adresse de la zone allouée. Charge à celui qui l'utilise (donc toi) de récupérer cette adresse pour la stocker dans un pointeur. C'est donc toi qui affecte la mémoire au pointeur, pas calloc...

Les choses sont plus claires maintenant.

Sûr ???