Discussion :

[Tziboun]

Bonjour,

le code contient un gros memory leak (entre autre) :

Code :

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

1
2
3
char *nom=malloc(50*sizeof(char));     // allocation de la mémoire pour chaque entrée
...
nom=strtok(buffer,sep);

On alloue de la mémoire pour nom, on écrase nom avec le résultat de strtok ...

Impossible de libérer la mémoire, et si on essaye (ce que j'ai conseillé) ça plante.

Tu veux dire Kwariz que j'ai alloué de la mémoire de nom pour rien ? car le pointeur vers nom va pointer vers le résultat de strtok ?
La mémoire allouée pour nom reste donc en suspens avec plus rien qui pointe dessus ? C'est cela qu'il se passe ou je me plante ?

[Tziboun]

C'est un coup de chance. Ton code n'est pas propre, et oublie nombre de choses.
Par ailleurs, utiliser malloc pour allouer une taille fixe de 50 caracteres, c'est inutile. Un tableau de char conviendra tres bien dans ton cas.
Malloc est a utiliser pour les grandes tailles et les objets de taille variable (en utilisation avec realloc dans ce cas), et il faut toujours verifier le code de retour.

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 entree
{
    char nom[50]; // J'alloue la mémoire de manière statique pour chaque entrée
    char prenom[50];
    char initiales[50];
    char mail[50];
    char tel[50];
    char classe[50];
    struct entree *next;
} ENTREE;




void nvl_entree(char buffer[],LISTE *liste) // Ajoute les lignes du fichier dans la liste chainnée => une ligne = une entree (un noeud) de la liste.
{
    ENTREE *n_entree=malloc(sizeof(ENTREE));
    char sep; //char sep[1];
    /*sep[0]=';'; */ /* On ne melange pas declaration et initialisation */
/*    char *nom=malloc(50*sizeof(char));
    char *prenom=malloc(50*sizeof(char));
    char *initiales=malloc(50*sizeof(char));
    char *mail=malloc(50*sizeof(char));
    char *tel=malloc(50*sizeof(char));
    char *classe=malloc(50*sizeof(char)); */

/* Tous avec la meme taile... C'est fortement discutable. En plus, on n'a pas besoin de chaines de caracteres, mais de pointeurs.*/
    char *nom;
    char *prenom;
    char *initiales;
    char *mail;
    char *tel;
    char *classe;

    sep = ';' ;

/* ATTENTION : ici, on modifie la chaine buffer !!! */
/* Tout reecrire en utilisant strncpy au lieu de strcpy. Mieux si disponible : strlcpy */
    nom=strtok(buffer,sep); 
    strcpy(n_entree->nom,nom);

/* j'arrete ici, ca fait deja pas mal */
.......

QUand tu dis qu'on a besoin de pointeurs et pas de chaines de cararctère tu fais référence à ce que dit aussi Kwariz par rapport au memory leak ?

Désole pour toutes ces questions, mais je suis étudiants et je veux être sur de bien comprendre ce qu'il se passe en mémoire plutôt que de rendre un travail qui fonctionne mais que je ne comprends pas à 100%.

[kwariz]

Tu veux dire Kwariz que j'ai alloué de la mémoire de nom pour rien ? car le pointeur vers nom va pointer vers le résultat de strtok ?
La mémoire allouée pour nom reste donc en suspens avec plus rien qui pointe dessus ? C'est cela qu'il se passe ou je me plante ?

C'est ça : impossible de libérer la mémoire allouée. strtok renvoie un pointeur qui pointer vers "l'intérieur" de buffer et cette adresse va écraser celle que malloc a alloué pour toi. Un free sur cette adresse (nom, ou une des suivantes) provoquera une erreur fatale.
Mais c'est en se plantant qu'on apprend, tout comme c'est en sciant que Léonard de Vinci

[gangsoleil]

QUand tu dis qu'on a besoin de pointeurs et pas de chaines de cararctère tu fais référence à ce que dit aussi Kwariz par rapport au memory leak ?

Oui.

Pour reformuler ce qu'il a dit :
Lorsque tu alloues de la memoire, tu reserves 50 octets dans la RAM : ils sont marques comme etant a toi, et tant que ton programme existe, tu pourras y mettre ce que tu veux. Pour y mettre quelque chose, tu as besoin de savoir ou sont ces octets ; cela est indique par l'adresse du pointeur nom.

Lorsque tu alloues un char * toto, tu n'alloues que le pointeur. C'est a dire un truc qui contient l'adresse d'une case memoire. Dans le cas de strtok, lors de l'utilisation, il te renvoit une adresse. Donc ce que tu fais dans ce cas, c'est de stocker l'adresse de cette case memoire dans ton pointeur. Ensuite, lors de l'appel a str(n/l)cpy, tu dis "copie les informations de la zone memoire dest vers ma_chaine".

Prenons maintenant ce que tu faisais :
tu alloues 50 octets, dont tu stockes l'adresse dans un pointeur que tu appelles nom.
Ensuite, tu fais pointer nom sur le resultat de strtok. Bah oui, mais tes 50 octets, ils sont toujours la quelque part, mais tu ne sais plus quelle est leur adresse -> C'est une fuite memoire de 50 octets.

Sur certains systemes d'exploitation, lors de la mort de ton programme, cette memoire est liberee, et rendue disponible pour les autres programmes. Mais ce n'est pas tout le temps le cas ; donc si tu imagines que tous les programmes ont des fuites memoires, au bout d'un moment, tu ne peux plus utiliser ta machine car il n'y a plus de memoire disponible.

[Tziboun]

Merci pour vos réponses , c'est le top =)