Discussion :

[metraon]

Bonjour

J'asseye de faire un programme qui lit un fichier texte et qui met les mots dans une liste simplement chaînée. Un mot par noeud.

En surface mon programme fonctionne correctement, seulement lorsque j'utilise valgrind pour verifier les fuites de mémoire, je m'aperçoit que je ne gère pas ma memoire convenablement.

En gros, je pene que strdup créé dynamiquement un pointeur vers une chaine de caractères pour chaque mot. Donc si mon fichier texte à 40 mots, il va y avoir 40 zones mémoires dynamiques que je dois effacer.

J'ai asseye de mettre le contenu du strdup dans un char * par exemple, et de faire free() sur cela à différents endroits. Résultat soit que j'ai une fuite de mémoire, soit que j'efface le pointeur trop top et il manque des mots dans ma liste.

Comment puis-je éviter les fuites avec strdup ?

Merci!

Mon main :

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
 
 
int main(int argc, char **argv)
{
    llist ma_liste = NULL;
    char tampon_mot[100];
 
    FILE *file = fopen("fichier.txt", "r");
 
    if(file == NULL) {
      printf("erreur ouverture de fichier\n");
      return 1;
    }
 
    while(fscanf(file, "%s", tampon_mot) == 1){
      ma_liste = ajouterEnTete(ma_liste, strdup(tampon_mot));
    }
    fclose(file);
    afficher_liste(ma_liste);
    effacerListe(ma_liste);
 
    return 0;
}

Ma structure pour ma liste chainée :

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
 
 
typedef struct element element;
struct element
{
    char * val;
    struct element *nxt;
};
 
typedef element* llist;
 
llist ajouterEnTete(llist liste, char * valeur)
{
    element* nouvelElement = malloc(sizeof(element));
    nouvelElement->val = valeur;
    nouvelElement->nxt = liste;
    return nouvelElement;
}
 
void afficherListe(llist liste)
{
    element *tmp = liste;
    while(tmp != NULL)
    {
        printf("%s ", tmp->val);
        tmp = tmp->nxt;
    }
    printf("\n");
}
 
llist effacerListe(llist liste)
{
    if(liste == NULL)
    {
        return NULL;
    }
    else
    {
        element *tmp;
        tmp = liste->nxt;
        free(liste);
        return effacerListe(tmp);
    }
}

[foetus]

Il manque la procédure la plus importante, celle pour supprimer un element, mais il n'y a rien de compliqué
À chaque suppression d'un element, il faut libérer la valeur.

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
void clearListe(llist* liste) {
    if (liste == NULL) { return; }
 
    element* tmp = (*liste);
    element* next;
 
    while(tmp != NULL) {
        if (tmp->val != NULL) {
            free(tmp->val);
//          tmp->val = NULL;
        }
 
        next = tmp->nxt;
 
        free(tmp);
 
        tmp = next;
    }
 
    (*liste) = NULL;
}

PS: N'oublie pas de tester si tmp->val est NULL avant de faire quelque chose.

[metraon]

Merci pour le tuyeau, à vrai dire j'avais oublié d'inclure le code plus haut. Voici ce que j'avais déjà.

À premiere vue, cela fonctionne mais valgrind m'indique encore une fuite de mémoire pour le strdup du main.

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
 
llist effacerListe(llist liste)
{
    if(liste == NULL)
    {
        return NULL;
    }
    else
    {
        element *tmp;
        tmp = liste->nxt;
        free(liste);
        return effacerListe(tmp);
    }
}

Il manque la procédure la plus importante, celle pour supprimer un element, mais il n'y a rien de compliqué
À chaque suppression d'un element, il faut libérer la valeur.

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
void clearListe(llist* liste) {
    if (liste == NULL) { return; }
 
    element* tmp = (*liste);
    element* next;
 
    while(tmp != NULL) {
        if (tmp->val != NULL) {
            free(tmp->val);
//          tmp->val = NULL;
        }
 
        next = tmp->nxt;
 
        free(tmp);
 
        tmp = next;
    }
 
    (*liste) = NULL;
}

PS: N'oublie pas de tester si tmp->val est NULL avant de faire quelque chose.

Ahhhh ! Je comprends, je liberais mes noeuds, mais pas le contenu des noeuds !

Merci beaucoup !

[Bktero]

En gros, je pene que strdup créé dynamiquement un pointeur vers une chaine de caractères pour chaque mot. Donc si mon fichier texte à 40 mots, il va y avoir 40 zones mémoires dynamiques que je dois effacer.

Toi, tu es presque devin ! Ou alors tu as lu le manuel

La fonction strdup() renvoie un pointeur sur une nouvelle chaîne de caractères qui est dupliquée depuis s. La mémoire occupée par cette nouvelle chaîne est obtenue en appelant malloc(3), et peut (doit) donc être libérée avec free(3).

Ahhhh ! Je comprends, je liberais mes noeuds, mais pas le contenu des noeuds !

La règle d'or est : un malloc = un free. Le corollaire doré : une boucle de malloc = une boucle de free. T'inquiète, on s'est déjà tous fait avoir.

[LittleWhite]

Bonjour,

C'est surtout que strdup est un peu une fonction piège : elle alloue de la mémoire (sans avoir de nom comme alloc/init). Il faut lire la documentation pour être certain qu'elle alloue de la mémoire (contrairement à beaucoup d'autres fonctions qui laisse cela pour l'utilisateur/ou encore, qui gère la mémoire en interne sans rien demander à l'utilisateur).