Problème liste chainée simple

Version imprimable

Bonsoir à tous,

J'ai un petit soucis dans le code suivant, j’espère que vous pourrez m'aider.
En gros il s'agit d'un programme qui lit les lignes d'un fichier texte et qui stocke les éléments dans une liste chaînée de structures.

Le problmème c'est que quand j'éssaye d'afficher le contenu de ma strucure à l'aide de printf, jle résultat est faux. Ma liste se remplit mal.

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAILLE 1000
 
/////////////DECLARATION DES TYPES///////////////
 
typedef struct entree
{
    char *nom;
    char *prenom;
    char *initiales;
    char *mail;
    char *tel;
    char *classe;
    struct entree *next;
} ENTREE;
 
typedef struct liste
{
    int t;
    struct entree *first;
} LISTE;
 
/////////////PROTOTYPES DE FONCTIONS/////////////
 
LISTE *lecture_fichier();
LISTE *creer_liste();
void nvl_entree(char buffer[],LISTE *liste);
void afficher_liste(LISTE *liste);
 
/////////////////////FONCTIONS///////////////////
 
LISTE *creer_liste()
{
    LISTE *n_liste = malloc(sizeof(LISTE));
    n_liste->t=0;
    n_liste->first=NULL;
    return n_liste;
}
 
LISTE *lecture_fichier()  // Parcours le fichier txte ligne par ligne et ajoute les entrées dans la liste via la fonction nvl_entree
{
    char buffer[81];
    char *nom_fichier=malloc(50*sizeof(char));
    LISTE *liste;
    liste=creer_liste();
    FILE *fichier;
    /*printf("entrez le nom du fichier a ouvrir  ");
    scanf("%s",nom_fichier);*/
    nom_fichier="fichier.txt";
    fichier = fopen(nom_fichier,"r");
    if(fichier!=NULL)
    {
        while(fgets(buffer,81,fichier)!=NULL)
        {
            nvl_entree(buffer,liste);
           // printf("%s\n",liste->first->nom); // CE PRINTF AFFICHE UN NOM   DIFFERENT A CHAQUE PASSAGE DANS LA BOUCLE ->  PQ ???? :'(
        }
 
        fclose(fichier);
    }
    else
    {
        printf("\n ! erreur de lecture du fichier ! ");
    }
    return liste;
}
 
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[1];
    sep[0]=';';
    n_entree->nom=strtok(buffer,sep);
    n_entree->prenom=strtok(NULL,sep);
    n_entree->initiales=strtok(NULL,sep);
    n_entree->mail=strtok(NULL,sep);
    n_entree->tel=strtok(NULL,sep);
    n_entree->classe=strtok(NULL,sep);
 
    if(liste->t==0)
    {
        liste->first=n_entree;
    }
    else
    {
        ENTREE *courant;
        courant=liste->first; //On part de la premiere entrée.
        while(courant->next!=NULL) //On avance dans la liste jusqu'à arriver à la dernière entrée.
        {
            courant=courant->next;
        }
         courant->next=n_entree;//lorsqu'on attent le dernier élément , on fait pointer la champ next de la dernier entree vers la nouvelle entrée
    }
    liste->t++;
}

merci d'avance pour votre aide... j'en peux plus de ne pas trouver mon érreur :'(

23/10/2012, 03h24
kwariz

Bonsoir,

en regardant en diagonal et sans tester : strtok renvoie des pointeur sur la chaine passée en paramètre, celle-ci est réutilisée à chaque fgets et a comme durée de vie l'appel de la fonction lecture_fichier => bug en perspective.
Donc j'essayerais d'initialiser les champs de n_entree non avec le résultat de strtok mais avec une copie de strtok (ou manuelle = allocation+str{n}cpy ou avec strdup si les extensions gnu sont dispo)

Alors il y a plusieurs trucs à corriger ( lol :mouarf: )

Utiliser des tableaux de char ou alors initialiser tes pointeurs comme l'a dit kwariz. (initialiser aussi les pointeurs des structures créées comme par exemple courant->next=null;)

J'aurais aussi d'abord mis les valeurs lues du fichier dans des chaines puis les auraient rentrées en paramètre de la fonction nvl_entree.
Et alors à l'intérieur de cette fonction, j'aurais copié les chaines reçu en paramètre dans ma structure n_entree qui elle sera ajouté ensuite à la fin de la liste.

Tu alloues nom_fichier pour rien et tu oublies de libérer la mémoire ensuite.
Pas oublier non plus de bien vider la liste.

:ccool:
Code corrigé:

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAILLE 1000
 
/////////////DECLARATION DES TYPES///////////////
 
typedef struct entree
{
    char nom[15];
    char prenom[15];
    char initiales[10];
    char mail[35];
    char tel[10];
    char classe[15];
    struct entree *next;
} ENTREE;
 
typedef struct liste
{
    int t;
    struct entree *first;
} LISTE;
 
/////////////PROTOTYPES DE FONCTIONS/////////////
 
LISTE *lecture_fichier();
LISTE *creer_liste();
void nvl_entree(char nom[15],char prenom[15],char initiales[10],char mail[35],char tel[10],char classe[15],LISTE *liste);
void afficher_liste(LISTE *liste);
void supprime_list(LISTE *list);
 
/////////////////////FONCTIONS///////////////////
 
LISTE *creer_liste()
{
    LISTE *n_liste = malloc(sizeof(LISTE));
    n_liste->t=0;
    n_liste->first=NULL;
    return n_liste;
}
 
LISTE *lecture_fichier()  // Parcours le fichier txte ligne par ligne et ajoute les entrées dans la liste via la fonction nvl_entree
{
    char buffer[256];
    char nom[15];
    char prenom[15];
    char initiales[10];
    char mail[35];
    char tel[10];
    char classe[15];
    char nom_fichier[]="fichier.txt";
    LISTE *liste=creer_liste();
    FILE *fichier;
    char *t,*c;
    /*printf("entrez le nom du fichier a ouvrir  ");
    scanf("%s",nom_fichier);*/
    fichier = fopen(nom_fichier,"r");
    if(fichier!=NULL)
    {
        while(fgets(buffer,sizeof(buffer),fichier)!=NULL)
        {
            if((t = strtok(buffer, ";")) == NULL) {
               printf("\n !!! parse error line !!!\n");
               }
               else {
                        strcpy(nom, t);
                    }
 
            if((t = strtok(NULL, ";")) == NULL) {
                printf("\n !!! parse error line !!!\n");
                }
                else {
                         strcpy(prenom, t);
                     }
             if((t = strtok(NULL, ";")) == NULL) {
                printf("\n !!! parse error line !!!\n");
                }
                else {
                         strcpy(initiales, t);
                     }
             if((t = strtok(NULL, ";")) == NULL) {
                printf("\n !!! parse error line !!!\n");
                }
                else {
                         strcpy(mail, t);
                     }
             if((t = strtok(NULL, ";")) == NULL) {
                printf("\n !!! parse error line !!!\n");
                }
                else {
                         strcpy(tel, t);
                     }
             if((t = strtok(NULL, ";")) == NULL) {
                printf("\n !!! parse error line !!!\n");
                }
                else {
                         strcpy(classe, t);
                         if ((c=strrchr(classe, '\n')) != NULL) *c='\0';
                     }
            nvl_entree(nom,prenom,initiales,mail,tel,classe,liste);
           // printf("%s\n",liste->first->nom); // CE PRINTF AFFICHE UN NOM DIFFERENT A CHAQUE PASSAGE DANS LA BOUCLE ->  PQ ???? :'(
        }
 
        fclose(fichier);
    }
    else
    {
        printf("\n ! erreur de lecture du fichier ! ");
    }
    return liste;
}
 
void nvl_entree(char nom[15],char prenom[15],char initiales[10],char mail[35],char tel[10],char classe[15],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));
    n_entree->next=NULL;
    strcpy(n_entree->nom,nom);
    strcpy(n_entree->prenom,prenom);
    strcpy(n_entree->initiales,initiales);
    strcpy(n_entree->mail,mail);
    strcpy(n_entree->tel,tel);
    strcpy(n_entree->classe,classe);
 
    if(liste->t==0)
    {
        liste->first=n_entree;
    }
    else
    {
        ENTREE *courant=liste->first; //On part de la premiere entrée.
        while(courant->next!=NULL) //On avance dans la liste jusqu'à arriver à la dernière entrée.
        {
            courant=courant->next;
        }
        courant->next=n_entree;//lorsqu'on attent le dernier élément , on fait pointer la champ next de la dernier entree vers la nouvelle entrée
 
    }
    liste->t++;
}
 
void afficher_liste(LISTE *liste)
{
    int t=1;
    if(liste->t==0)
    {
        printf("Liste vide");
    }
    else
    {
 
        ENTREE *courant=liste->first;
        printf("Entree 0: %s %s %s %s %s %s\n",courant->nom,courant->prenom,courant->initiales,courant->mail,courant->tel,courant->classe);
        courant=courant->next;
        while(courant!=NULL)
        {
 
            printf("Entree %d: %s %s %s %s %s %s\n",t,courant->nom,courant->prenom,courant->initiales,courant->mail,courant->tel,courant->classe);
            courant=courant->next;
            t++;
        }
    }
}
void supprime_list(LISTE *list)
{
    if (list != NULL)
    {
        ENTREE *p_tmp = list->first;
        while (p_tmp != NULL)
        {
            ENTREE *p_del = p_tmp;
            p_tmp = p_tmp->next;
            free(p_del);
        }
        free(list), list = NULL;
    }
}
//////////////////////MAIN///////////////////////////
 
int main()
{
    LISTE *liste;
    liste=lecture_fichier();
    afficher_liste(liste);
    supprime_list(liste);
    return 0;
}

23/10/2012, 07h54
gangsoleil

Bonjour,

Je te conseille d'utiliser sscanf plutot que strtok, a moins bien sur que le but de la manoeuvre ne soit de t'entrainer a utiliser cette fonction ?

http://xrenault.developpez.com/tutoriels/c/scanf/

oui mais...

Ce que je ne comprends pas c'est que quand je met un printf à
nvl_entree->nom ou nvl_entree->"quoi que ce soit" , je récupere bien le mot que je voulais entrer donc pourquoi changer toute la saisie si cela fonctionne correctement ??

Ce qui ne fonctionne pas c'est après, c'est le stockage dans la liste chainnée..

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAILLE 1000
 
/////////////DECLARATION DES TYPES///////////////
 
typedef struct entree
{
    char *nom;
    char *prenom;
    char *initiales;
    char *mail;
    char *tel;
    char *classe;
    struct entree *next;
} ENTREE;
 
typedef struct liste
{
    int t;
    struct entree *first;
} LISTE;
 
/////////////PROTOTYPES DE FONCTIONS/////////////
 
LISTE *lecture_fichier();
LISTE *creer_liste();
void nvl_entree(char buffer[],LISTE *liste);
void afficher_liste(LISTE *liste);
 
/////////////////////FONCTIONS///////////////////
 
LISTE *creer_liste()
{
    LISTE *n_liste = malloc(sizeof(LISTE));
    n_liste->t=0;
    n_liste->first=NULL;
    return n_liste;
}
 
LISTE *lecture_fichier()  // Parcours le fichier txte ligne par ligne et ajoute les entrées dans la liste via la fonction nvl_entree
{
    char buffer[81];
    char *nom_fichier=malloc(50*sizeof(char));
    LISTE *liste;
    liste=creer_liste();
    FILE *fichier;
    /*printf("entrez le nom du fichier a ouvrir  ");
    scanf("%s",nom_fichier);*/
    nom_fichier="fichier.txt";
    fichier = fopen(nom_fichier,"r");
    if(fichier!=NULL)
    {
        while(fgets(buffer,81,fichier)!=NULL)
        {
            nvl_entree(buffer,liste);
           // printf("%s\n",liste->first->nom); // CE PRINTF AFFICHE UN NOM DIFFERENT A CHAQUE PASSAGE DANS LA BOUCLE ->  PQ ???? :'(
        }
 
        fclose(fichier);
    }
    else
    {
        printf("\n ! erreur de lecture du fichier ! ");
    }
    return liste;
}
 
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[1];
    sep[0]=';';
    n_entree->nom=strtok(buffer,sep);
    n_entree->prenom=strtok(NULL,sep);
    n_entree->initiales=strtok(NULL,sep);
    n_entree->mail=strtok(NULL,sep);
    n_entree->tel=strtok(NULL,sep);
    n_entree->classe=strtok(NULL,sep);
    printf("%s",n_entree->prenom); // FONCTIONNE bien et affiche successivement tous les prenoms enregistres dans le fichier !!!
 
    if(liste->t==0)
    {
        liste->first=n_entree;
    }
    else
    {
        ENTREE *courant;
        courant=liste->first; //On part de la premiere entrée.
        while(courant->next!=NULL) //On avance dans la liste jusqu'à arriver à la dernière entrée.
        {
            courant=courant->next;
        }
         courant->next=n_entree;//lorsqu'on attent le dernier élément , on fait pointer la champ next de la dernier entree vers la nouvelle entrée
    }
    liste->t++;
}

23/10/2012, 13h57
Tziboun

aaaah oké , je viens de tilter... le strtok fait pointer vers quelque chose qui n'éxiste plus à la sortie de la fonction..

Je vais regarder ca .. :ccool:

merci !!

Yeees !

Voilà,en éffet c'était ca..
J'ai corrigé le code comme suit et ca fonctionne =) =) :

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
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[1];
    sep[0]=';';
    char *nom=malloc(50*sizeof(char));     // allocation de la mémoire pour chaque entrée 
    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));
 
    nom=strtok(buffer,sep); 
    strcpy(n_entree->nom,nom);
 
    prenom=strtok(NULL,sep);
    strcpy(n_entree->prenom,prenom);
 
    initiales=strtok(NULL,sep);
    strcpy(n_entree->initiales,initiales);
 
    mail=strtok(NULL,sep);
    strcpy(n_entree->mail,mail);
 
    tel=strtok(NULL,sep);
    strcpy(n_entree->tel,tel);
 
    classe=strtok(NULL,sep);
    strcpy(n_entree->classe,classe);
 
    if(liste->t==0)
    {
        liste->first=n_entree;
    }
    else
    {
        ENTREE *courant;
        courant=liste->first; //On part de la premiere entrée.
        while(courant->next!=NULL) //On avance dans la liste jusqu'à arriver à la dernière entrée.
        {
            courant=courant->next;
        }
         courant->next=n_entree;//lorsqu'on attent le dernier élément , on fait pointer la champ next de la dernier entree vers la nouvelle entrée
    }
    liste->t++;
}

merci !!!

23/10/2012, 14h43
kwariz

N'oublies pas de gérer aussi la libération de la mémoire ... c'est important.
23/10/2012, 14h48
Tziboun

merci

:whistle2:

Juste ....

Je vais reiterer ma question : pourquoi pas sscanf ?

Un truc du genre :

Code:

1
2
3
4
5
6
7
8
/* ... */
ret_code = sscanf (chaine, "%s;%s;%s;%s;%s;%s;\n", nom, prenom, initiales, mail, tel, classe);
 
/* check if sscanf read successfully all of its arguments */
if (ret_code != 6)
{
  /* gestion d'erreur */
  /* ... */

23/10/2012, 17h32
toufik135

re

J'ai dis tout ça dans ma réponse (-_-')
-> voir le code corrigé

Gangsoleil, on m'ignore aussi, ne t'inquiète pas lol.

Par contre, ça m'intéresse de savoir pourquoi privilégier sscanf plutôt que strtok??
Juste pour économiser des lignes ou il y a une autre raison?
23/10/2012, 18h00
Tziboun

à touff

le truc c'est que t'as beaucoup changé le côde, en changeant la manière dont j'ai passé les parametres , en utilisant strtok en dehors de la sous fonction etc.. .. donc ca devient chaud pointer l'érreur de logique précise qui fait foirer le code ... mais j'ai lu ce que tu m'as écrit mec =)
23/10/2012, 18h02
Tziboun

sscanf

Je n'ai pas utilisé sscanf parce-que j'avais pas réalisé que c'étiat possible de faire ca simplement comme ca :| ... j'avoue que ca à l'air plus simple.
D'autant que j'ai lu sur ce même site que strtok était à éviter ... :aie:
23/10/2012, 18h32
gangsoleil

Citation:

Envoyé par toufik135

Par contre, ça m'intéresse de savoir pourquoi privilégier sscanf plutôt que strtok??
Juste pour économiser des lignes ou il y a une autre raison?

Citation:

Envoyé par Tziboun

D'autant que j'ai lu sur ce même site que strtok était à éviter ... :aie:

strtok a l'enorme inconvenient de modifier la chaine sur laquelle il travaille (remplacement du token par un '\0' si je me souviens bien), ce qui peut s'averer problematique, notamment dans une librairie.
Inconvenient moindre : il n'est pas thread-safe, c'est a dire que si tu as un programme avec deux threads qui font appel a strtok, c'est un joyeux bordel.

Bonjour,

Je suis le seul que ça choque un malloc sur un tableau déclaré en dur?

sinon je serais partis plus la dessus pour la liste.

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
 
typedef struct s_list
{
  void* elem;
  s_list* next;
}t_list;
 
void add_elem(t_list** lst, void* elem)
{
  t_list* tmp;
 
   tmp = *lst;
 
   while(tmp->next != null)
       tmp = tmp->next;
 
   tmp->next = malloc(sizeof(t_list));
   tmp = tmp->next;
   tmp->elem = elem;
   tmp->next = null;
}
 
void lecture()
{
  t_list* lst;
 
 lst = malloc(sizeof(t_list));
  lst->next = null;
 
    while(...)
   {
      //recup des donnees
     // Mon traitement de création de l'elem + remplissage;
     add_elem(&lst, mon_elem);
   }
}
 
 
void affichage(t_list* lst)
{
   t_list* tmp = lst;
 
   while(tmp != null)
   {
      printf(....);
      tmp = tmp->next;
   }
}

Enfin un truc dans le genre.

Et l'avantage de cette méthode et que ta liste chainé est ré utilisable dans tous tes projets après.

Bonne soirée

23/10/2012, 23h49
toufik135

à jouana

Citation:

Je suis le seul que ça choque un malloc sur un tableau déclaré en dur?

A quel ligne t'as vu ça?

C'est vrai qu'on voit que le code que t'as mis est plus portable mais de la à dire que les autres sont pas réutilisable, je pense moi que son code aussi est réutilisable. (sauf si t'as des raisons qui me feront changer d'avis, on sait jamais lol :p)

Citation:

Envoyé par Tziboun

Yeees !

Voilà,en éffet c'était ca..
J'ai corrigé le code comme suit et ca fonctionne =) =) :

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:

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 */ .......

24/10/2012, 10h59
jouana

Ok pour la partie choquant j'ai pas bien lu tout le code :roll:

Par contre déclaré des variable pour mettre les infos dedans et ensuite faire des strcpy de ces infos dans la structure pas trop aussi bien remplir directement la structure pcq la en terme d'execution inutile c'est pas mal 2 fois le même traitement :s
24/10/2012, 11h05
kwariz
Bonjour,

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

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.

correction

Ce n'était en effet pas fameux et je me suis embrouillé pas mal dans la gestion de la mémoire. Résultat ca plantait aléatoirement...

Voici la version simplifiée et qui tourne tout le temps...
J'utulise sscanf : Ca fonctionne bien et c'est plus simple quand on a compris sa syntaxe.
J'évite la création de pointeurs ou de variables inutiles..

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
34
35
36
37
38
39
40
41
42
43
44
45
46
 
LISTE *lecture_fichier()  // Parcours le fichier txte ligne par ligne et ajoute les entrées dans la liste via la fonction nvl_entree
{
    char buffer[350];
    char nom_fichier[]="fichier.txt";
    LISTE *liste=creer_liste();
    FILE *fichier;
    fichier = fopen(nom_fichier,"r");
    if(fichier!=NULL)
    {
        while(fgets(buffer,sizeof(buffer),fichier)!=NULL)
        {
            nvl_entree(buffer,liste);
        }
 
        fclose(fichier);
    }
    else
    {
        printf("\n ! erreur de lecture du fichier ! ");
    }
    return liste;
}
 
void nvl_entree(char buffer[350],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));
    n_entree->next=NULL;
 
    sscanf(buffer,"%[^;]; %[^;]; %[^;]; %[^;]; %[^;]; %s ",n_entree->nom,n_entree->prenom,n_entree->initiales,n_entree->mail,n_entree->tel,n_entree->classe);
    if(liste->t==0)
    {
        liste->first=n_entree;
    }
    else
    {
        ENTREE *courant;
        courant=liste->first; //On part de la premiere entrée.
        while(courant->next!=NULL) //On avance dans la liste jusqu'à arriver à la dernière entrée.
        {
            courant=courant->next;
        }
        courant->next=n_entree;//lorsqu'on attent le dernier élément , on fait pointer la champ next de la dernier entree vers la nouvelle entrée
    }
    liste->t++;
}

24/10/2012, 16h49
Tziboun
Citation:
Envoyé par kwariz

Bonjour,

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

Code:

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 ? :weird::oops:

Citation:
Envoyé par gangsoleil
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:

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

24/10/2012, 17h43
kwariz

Citation:

Envoyé par Tziboun

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 ? :weird::oops:

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 :)
25/10/2012, 07h43
gangsoleil

Citation:

Envoyé par Tziboun

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.
25/10/2012, 14h43
Tziboun

merci

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