[Valgrind]Probleme de malloc detecté et fuites memoire (petite précision le projet fonctionne )

bonjour ,
j'ai vraiment besoin d'aide, je ne m'en sort pas avec mon projet
avez vous une idée du probleme ?

Citation:

---

==4941== Invalid write of size 1
==4941== at 0x4026107: strcpy (mc_replace_strmem.c:311)
==4941== by 0x804B8B0: ruleFromString (regle.c:129) / ligne 16 dans le past
==4941== by 0x804EADC: loadRuleBase (persistance.c:212)
==4941== by 0x80492ED: morpionGame (morpion.c:150)
==4941== by 0x804EEAB: main (main.c:37)
==4941== Address 0x46d9842 is 7 bytes after a block of size 3 alloc'd
==4941== at 0x4024F20: malloc (vg_replace_malloc.c:236)
==4941== by 0x804B87F: ruleFromString (regle.c:126)
==4941== by 0x804EADC: loadRuleBase (persistance.c:212)
==4941== by 0x80492ED: morpionGame (morpion.c:150)
==4941== by 0x804EEAB: main (main.c:37)
==4941==
==4941== Invalid read of size 1
==4941== at 0x402665C: strcmp (mc_replace_strmem.c:426)
==4941== by 0x804D556: moteurInfAR (moteur.c:108) // LIGNE 13 dans le past
==4941== by 0x8049950: morpionGame (morpion.c:269)
==4941== by 0x804EEAB: main (main.c:37)
==4941== Address 0x46d983b is 0 bytes after a block of size 3 alloc'd
==4941== at 0x4024F20: malloc (vg_replace_malloc.c:236)
==4941== by 0x804B87F: ruleFromString (regle.c:126)
==4941== by 0x804EADC: loadRuleBase (persistance.c:212)
==4941== by 0x80492ED: morpionGame (morpion.c:150)
==4941== by 0x804EEAB: main (main.c:37)
==4941==
==4941== Invalid read of size 1
==4941== at 0x402665C: strcmp (mc_replace_strmem.c:426)
==4941== by 0x804D556: moteurInfAR (moteur.c:108)
==4941== by 0x8049979: morpionGame (morpion.c:270)
==4941== by 0x804EEAB: main (main.c:37)
==4941== Address 0x46d983b is 0 bytes after a block of size 3 alloc'd
==4941== at 0x4024F20: malloc (vg_replace_malloc.c:236)
==4941== by 0x804B87F: ruleFromString (regle.c:126)
==4941== by 0x804EADC: loadRuleBase (persistance.c:212)
==4941== by 0x80492ED: morpionGame (morpion.c:150)
==4941== by 0x804EEAB: main (main.c:37)

---

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

short ruleFromString( char* ruleString,Rule* r) { char* token = NULL; // Partie de string char* hypo = NULL; short length;   listInit(&(r->hypo)); token = strtok(ruleString, " ");   //parcours des hypotheses while (token != NULL) { length = sizeof(char) * (strlen(token)+1); if(strcmp(token,"->")==0) { // Test : fin des hypothèses token = strtok(NULL," "); // NULL : prend la derniere chaine de caractères stockée if(token==NULL) return -1; r->concl = malloc((length)); // pb detecte avec valgrind if(r->concl == NULL) // Test du malloc return -1; strcpy(r->concl,token); // pb detecte avec valgrind return 1; } hypo = malloc(length); strcpy(hypo, token); if(!listPushBack(&(r->hypo),(void*) hypo)) { // Test fonctionnement de listPushBack ? listRemoveAll(&(r->hypo)); // Suppression de toutes les hypothèses return -1; } token = strtok(NULL," "); } return 1; }

---

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

short moteurInfAR(List listRules, List listFacts,char *but) {   Rule *rule = NULL; char *hypo = NULL; short flag_allHypoFound = 0; int i = 0; int j = 0;   if(elementSearch(listFacts,but) == 1) // Si but est dans les faits return 1; for (i = 0; i < listLength(listRules); i++) { // Parcours de la liste de règles rule = (Rule *) listGetElement(listRules, i); if (strcmp (but,rule->concl)== 0) { // Si le but est la conclusion d'une des règles flag_allHypoFound = 1; for (j = 0; j < listLength(rule->hypo); j++) { // Parcours des hypothèses d'une règle hypo = (char*) listGetElement(rule->hypo, j); if (elementSearch(listFacts, hypo) == 0)// Si une hypo n'est pas dans la base de faits ,flag_allHypoFound = 0 flag_allHypoFound = 0; } if(flag_allHypoFound) // Si un but est verifié , arrêt du parcourt de la liste regles break; } else flag_allHypoFound = 0; } return flag_allHypoFound; }

---

Bonjour,
j'ai très souvent eu ce genre de problème, et en général je l'ai résolu en passant le malloc (strlen(string)+1) a malloc(strlen(string+2)).
Les invalide read et write surviennent en effet lors de malloc trop petit.
En espérant que cela puisse vous aider.

Citation:

---

Envoyé par Arofu

Bonjour,
j'ai très souvent eu ce genre de problème, et en général je l'ai résolu en passant le malloc (strlen(string)+1) a malloc(strlen(string+2)).
Les invalide read et write surviennent en effet lors de malloc trop petit.
En espérant que cela puisse vous aider.

---

malloc(strlen(string+2)). ou malloc(strlen(string)+2). ???

j'ai tenté les deux solutions , je n'ai pas d'ameliorations :(

merci tout de meme !

deja dans la fonction moteurarinf il manque le malloc de rule .
ou faut t'il ajouter le malloc et le free pour char *rule??

(je precise je debute )

ajout de quelques informations

Code:

---

1 2	listFacts est une liste de char listRules est une liste de struct rule

---

Code:

---

1 2 3 4

typedef struct node { void* data; struct node* suiv; } Node;

---

Code:

---

typedef Node* List

---

Code:

---

1 2 3 4 5

typedef struct rule { List hypo; char* concl;   } Rule;

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11

Rule* ruleCreate() { Rule* newRule = malloc(sizeof(Rule)); if(newRule != NULL) { //Test du malloc newRule->concl = NULL; // Initialisation de la conclusion listInit(&(newRule->hypo)); // Initialisation de la liste d'hypothèses } else return NULL;   return newRule; }

---

Pardon, je voulais bien dire malloc(strlen(string)+2) comme vous le pensiez.
Vous parlez d'un char *rule sans malloc dans la fonction moteurarinf, pouvez vous nous montrer le code, nous voyons ici un Rule *rule dans la fonction moteurInfAR.

Par ailleur, pour quelle raisons en êtes vous arrivé a valgrind, cela causait il un soucis sérieux dans le fonctionnement du programme ?

Citation:

---

Envoyé par Arofu

Pardon, je voulais bien dire malloc(strlen(string)+2) comme vous le pensiez.
Vous parlez d'un char *rule sans malloc dans la fonction moteurarinf, pouvez vous nous montrer le code, nous voyons ici un Rule *rule dans la fonction moteurInfAR.

Par ailleur, pour quelle raisons en êtes vous arrivé a valgrind, cela causait il un soucis sérieux dans le fonctionnement du programme ?

---

je parlé de moteurInfAR. ( mauvaise syntaxe)
mon programme ( un morpion) consomme plusieur MO de ram par minutes :(
et ne les rend pas , valgrind c'etait pour detecter les fuite memoires et j'ai decouvent sa .

a part sa le programme marche parfaitement .

c'est un projet scolaire que je dois rendre samedi ..

Une autre idée qui ne devrait pas changer grand chose mais ne sait on jamais.
Remplacez : length = sizeof(char) * (strlen(token)+1);
Par: length = sizeof(char *) * (strlen(token)+1);

Que fait la fonction ListGetElement dans moteurarinf ? Elle utilise rule, dont vous dites qu'il n'est pas malloqué. Mais je constate par contre que ce n'est pas un char *.

Enfin, le fait de corriger l'invalide read et l'invalide write ne corrigera sans pas vos fuites de mémoire, elles doivent provenir du fait que vous malloquez un pointeur a chaque tour de boucle sans jamais le free, ce qui a pour conséquence le pointeur précédant est perdu et reste en mémoire.

Citation:

---

Envoyé par Arofu

Une autre idée qui ne devrait pas changer grand chose mais ne sait on jamais.
Remplacez : length = sizeof(char) * (strlen(token)+1);
Par: length = sizeof(char *) * (strlen(token)+1);

Que fait la fonction ListGetElement dans moteurarinf ? Elle utilise rule, dont vous dites qu'il n'est pas malloqué. Mais je constate par contre que ce n'est pas un char *.

Enfin, le fait de corriger l'invalide read et l'invalide write ne corrigera sans pas vos fuites de mémoire, elles doivent provenir du fait que vous malloquez un pointeur a chaque tour de boucle sans jamais le free, ce qui a pour conséquence le pointeur précédant est perdu et reste en mémoire.

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

void* listGetElement(List l,int index) { Node* currentNode = NULL ; currentNode = l; int i; if(listIsEmpty(l)) return NULL; if(index < 0 || index > (listLength(l)-1)) return NULL; for( i=0;i< index;i++) { currentNode = currentNode->suiv; } return currentNode->data; }

---

D'après le code de votre fonction ListGetElement, Rule *rule n'a pas besoin de malloc car vous le faite pointer sur un espace déjà malloqué et contenant les données voulues.

Une chose que je n'avais pas remarquée avant:

Citation:

---

length = sizeof(char) * (strlen(token)+1);
if(strcmp(token,"->")==0) { // Test : fin des hypothèses
token = strtok(NULL," "); // NULL : prend la derniere chaine de caractères stockée
if(token==NULL)
return -1;
r->concl = malloc((length)); // pb detecte avec valgrind
if(r->concl == NULL) // Test du malloc

---

Vous assignez une valeur a lenght, cependant la valeur de token peut changer dans le if juste après, donc sa longueur aussi. Si token prend une valeur un peu plus longue a ce moment, vous ne changez pas lenght, et r->concl est donc trop petit.

Essayer de rentrer :
r->concl = malloc ((strlen(token) + 1) * sizeof(char *)

Je ne garantit rien mais cela pourrait enlever les erreurs.

Deux remarques concernant ruleFromString()

- Cette fonction ne doit pas prendre en argument n°1 une chaine constante comme par exemple ruleFromString("abcdef",...), sinon plantage à cause du strtok().

- length n'est pas toujours la longueur de token :

Code:

---

1 2 3 4 5 6 7 8 9 10

length = strlen(token)+1; if(strcmp(token,"->")==0) { token = strtok(NULL," "); // token a changé mais pas length .... r->concl = malloc(length); .... strcpy(r->concl,token); return 1; }

---

Citation:

---

Envoyé par diogene

Deux remarques concernant ruleFromString()

- Cette fonction ne doit pas prendre en argument n°1 une chaine constante comme par exemple ruleFromString("abcdef",...), sinon plantage à cause du strtok().

- length n'est pas toujours la longueur de token :

Code:

---

1 2 3 4 5 6 7 8 9 10

length = strlen(token)+1; if(strcmp(token,"->")==0) { token = strtok(NULL," "); // token a changé mais pas length .... r->concl = malloc(length); .... strcpy(r->concl,token); return 1; }

---

---

merci
que me propose tu pour regler le probleme ?
au cas ou le but de la fonction est de convertir par exemple :

"ae Az 1A -> SD ;" lu dans un fichier texte
en

struct de type rule
list hypo = ae Az 1A
concl = SD

bon avec sa je n'ai plus d'erreur avec valgrind

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

short ruleFromString( char* ruleString,Rule* r) { char* token = NULL; // Partie de string char* hypo = NULL; short length; listInit(&(r->hypo)); token = strtok(ruleString, " "); //parcours des hypotheses while (token != NULL) { if(strcmp(token,"->")==0) { // Test : fin des hypothèses token = strtok(NULL," "); // NULL : prend la derniere chaine de caractères stockée if(token==NULL) return -1; length = sizeof(char) * (strlen(token)+2); r->concl = malloc((length)); // pb detecte avec valgrind if(r->concl == NULL) // Test du malloc return -1; strcpy(r->concl,token); // pb detecte avec valgrind return 1; } length = sizeof(char) * (strlen(token)+2); hypo = malloc(length); strcpy(hypo, token); if(!listPushBack(&(r->hypo),(void*) hypo)) { // Test fonctionnement de listPushBack ? listRemoveAll(&(r->hypo)); // Suppression de toutes les hypothèses return -1; } token = strtok(NULL," "); } return 1; }

---

par contre j'ai toujours un grosse fuite de memoire
(il faut precisser que cette fonction est apelle un tres tres grand nombre de foix dans mon programme )

ne faudrait t'il pas faire un free quelque part ?

Le problème venait donc bien du changement de la taille de token.

Pour ce qui est des fuites de mémoire, je ne pense pas que l'on pourra t'aider ici, c'est a toi de chercher dans tout ton code ou sont fait tes malloc, et pour chacun d'entre eux, de voir si il faut faire un free a la fin du tour de boucle, de la fonction, du programme ... Regarde surtout du coté des variable auxquelles tu assigne un espace mémoire a chaque tour de boucle comme je te le disais.

dans une boucle :

char *str;

tour 1: str = malloc 6
str = "Salut"

tour 2: str = malloc 7

Avec ce genre de procédé, l'espace que tu as malloc au premier tour est perdu et ne sera jamais free, d'ou les fuites de mémoire.

En espérant t'avoir aidé.

Citation:

---

Envoyé par Arofu

Le problème venait donc bien du changement de la taille de token.

Pour ce qui est des fuites de mémoire, je ne pense pas que l'on pourra t'aider ici, c'est a toi de chercher dans tout ton code ou sont fait tes malloc, et pour chacun d'entre eux, de voir si il faut faire un free a la fin du tour de boucle, de la fonction, du programme ... Regarde surtout du coté des variable auxquelles tu assigne un espace mémoire a chaque tour de boucle comme je te le disais.

dans une boucle :

char *str;

tour 1: str = malloc 6
str = "Salut"

tour 2: str = malloc 7

Avec ce genre de procédé, l'espace que tu as malloc au premier tour est perdu et ne sera jamais free, d'ou les fuites de mémoire.

En espérant t'avoir aidé.

---

justement dans ce cas comment liberer la memoire ?
la fuite de memoire provient en grande partie de la fonction ruleFromString

Eh bien celui qui me semble poser problème est le malloc de (rule->concl). Il faut que tu vois l'endroit ou tu l'utilise dans la fonction qui appelle ruleFromString, et que tu le free dès que tu n'en as plus besoin.

en gros, voici l'utilisation a faire avec Rule:

fonction d'appelle:
declaration de Rule
appelle de ruleFromString (Rule_>concl sera malloc ici)
utilisation de rule->concl
free (rule->concl)

Car si j'ai bien compris, tu n'utilise cette variable qu'une seule fois pour ensuite l'écraser. C'est le même principe pour toutes les variables.

sur le meme principe j'ai une fonction qui traite mais fait
forme d'un fait ex : AX ;
ooi ;
1zzz ;

cette fonction marche parfaitement :) et ne genere pas de fuite , ne serai t'il possible d'adapter la fonction rulefromstring pour qu'elle fonctionne de la meme maniere ?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

short factFromString(char* factString, char **f) { char *token = NULL; token = strtok(factString, " "); strcpy(*f, token);   if(f != NULL) return 1; else return 0;   }

---

Ce que je peux te conseiller maintenant, c'est d'essayer de partitionner ton code pour ta recherche de fuites de mémoire.
En partant de ton main par exemple, passe un des fonctions appelées en commentaire pour voir les fuites de mémoire occasionnées par les autres. Fonctionne ainsi jusqu'à voir laquelle créer le plus de fuite pour ensuite pouvoir les supprimer facilement regardant l'utilisation que tu fait par la suite de cette variable.

exemple:

int main()
{
recuperation de variable
traitement de variable
affichage de resultats
}

Dans un main comme celui ci, commence par mettre 'traitement de variable' et 'affichage de resultats' en commentaire et execute valgrind simplement sur la partie 'recupération de variable'.
Fait cela également pour des sous fonction et tu aura l'origine de tes fuites de mémoire.

une dernier question
je voudrais passer r en double *
et pouvoir ainsi me debarasser des malloc
pouvez vous me refaire la fonction avec un prototype
[B]short ruleFromString( char* ruleString,Rule** r)
un peu comme sa , mais la sa fonctionne pas

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

short ruleFromString( char* ruleString,Rule** r) { char* token = NULL; // Partie de string char* hypo = NULL; listInit(&(r->hypo)); token = strtok(ruleString, " "); //parcours des hypotheses while (token != NULL) { if(strcmp(token,"->")==0) { // Test : fin des hypothèses token = strtok(NULL," "); // NULL : prend la derniere chaine de caractères stockée if(token==NULL) return -1; strcpy(r->concl,token); // pb detecte avec valgrind return 1; } strcpy(hypo, token); if(!listPushBack(&(r->hypo),(void*) hypo)) { // Test fonctionnement de listPushBack ? listRemoveAll(&(r->hypo)); // Suppression de toutes les hypothèses return -1; } token = strtok(NULL," "); } return 1; }

---

Je pense qu'il vous sera plus difficile de passer r en **. Il vous faudra malloc le premier pointeur au nombre d'élément que vous metterez dedans. Ce qui impose de connaitre le nombre d'élément que l'on aura dès le départ ou bien de modifier le malloc pendant l'avancement du programme.

Le plus envisageable si vous voulez éviter de perdre ces pointeur r serait selon moi de créer un liste chaînée pour cet élément, surtout que vous avez l'air d'en utiliser, vous saurez donc comment faire.
Si vous avez besoin d'aide pour ajouter les élément comme vous le souhaitez dans la liste, demandez moi.