Discussion :

[stephane13100]

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

==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 :

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
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 :

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
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;
}

[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.

[stephane13100]

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 )

[stephane13100]

ajout de quelques informations

Code :

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

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

Code :

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

1
2
3
4
typedef struct node {
	void* data;
	struct node* suiv;
} Node;

Code :

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

typedef Node* List

Code :

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

1
2
3
4
5
typedef struct rule {
    List hypo;
    char* concl;
 
} Rule;

Code :

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

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;
}

[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 ?

[stephane13100]

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 .

[stephane13100]

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

[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.

[stephane13100]

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 :

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

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;
}

[Arofu]

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:

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.

[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 :

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

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;
        }

[stephane13100]

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 :

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

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

[stephane13100]

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

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
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 ?

[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é.

[stephane13100]

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

[Arofu]

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.

[stephane13100]

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 :

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

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;
 
}

[Arofu]

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.

[stephane13100]

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 :

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
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;
}

[Arofu]

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.