Discussion :

[Tziboun]

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 :

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

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

[toufik135]

Alors il y a plusieurs trucs à corriger ( lol )

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.


Code corrigé:

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

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

[Tziboun]

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 :

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

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

[Tziboun]

Yeees !

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

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

[kwariz]

N'oublies pas de gérer aussi la libération de la mémoire ... c'est important.

[Tziboun]

Juste ....

[gangsoleil]

Je vais reiterer ma question : pourquoi pas sscanf ?

Un truc du genre :

Code :

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

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

[toufik135]

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?

[Tziboun]

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

[Tziboun]

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

[gangsoleil]

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?

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

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.

[jouana]

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 :

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

[toufik135]

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)

[gangsoleil]

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 :

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

[jouana]

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

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

[kwariz]

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.

[Tziboun]

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 :

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