Problème liste chainée double

Version imprimable

Bonsoir,

Mon problème est le suivant, j'ai un fichier .csv contenant une liste d'élève ( nom,prénom,initial,email,téléphone,classe).
Cela représente ma structure ELEVE et je dois créer une liste chainée double.

Je l'ai donc fait et le problème est qu'en testant mon programme, ça plante.
Je suis sous Windows, j'ai quand même testé le debugger et cela m'a dit segmentation fault donc j'ai à priori un débordement de mémoire mais je ne sais pas ou se situe l'erreur dans l'allocation ou la libération de la mémoire.
J'ai testé et testé.., toujours rien donc étant un peu désespéré, j'espère trouver de l'aide sur ce forum.

Voici mon code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct DATA{
   char nom[15];
   char prenom[15];
   char initial[5];
   char email[30];
   unsigned int num_tel;
   int taille;
   char classe[15];
   struct DATA *next;
   struct DATA *previous;
};
typedef struct DATA ELEVE;
void init_list(ELEVE *debut)
{
    debut->num_tel = 0;
    debut->taille = 0;
    debut->next = NULL;
    debut->previous = NULL;
}
void add_eleve(ELEVE *debut, ELEVE *nouveau)
{
    if (debut->taille == 0)
       {
           debut->taille = 1;
           debut->next = nouveau;
           nouveau->previous = debut;
       }
       else{
               ELEVE *current = malloc(sizeof(ELEVE));
               current = debut->next;
               int i;
               for(i=1;i<debut->taille;i++)
                  {
                      current=current->next;
                  }
                current->next = nouveau;
                nouveau->previous = current;
                debut->taille++;
                nouveau->taille = debut->taille;
            }
}
ELEVE *buildEleve (char nom[15],char prenom[15],char initial[5],char email[30],unsigned int num_tel,char classe[15])
{
    ELEVE *data=malloc(sizeof(ELEVE));
    init_list(data);
    strcpy(data->nom,nom);
    strcpy(data->prenom,prenom);
    strcpy(data->initial,initial);
    strcpy(data->email,email);
    data->num_tel=num_tel;
    strcpy(data->classe,classe);
    return data;
}
ELEVE *load_fichier(char *path)
{
    ELEVE *debut = malloc(sizeof(ELEVE));
    init_list(debut);                                            //initialisation de la liste
    char *c;
    int i;
    FILE *file = fopen(path,"r");
    if(file==NULL)
       {
           printf("\n impossible d'ouvrir le fichier \n\n");
           return 0;
       }
    char tmp[50];
    char *nom[15];
    char *prenom[15];
    char *initial[5];
    char *email[30];
    unsigned int *num_tel=malloc(29 * sizeof(unsigned int));
    char *classe[15];
    for(i=0;i<28;i++)
        {
            nom[i]=malloc(strlen(tmp) + 1);
            prenom[i]=malloc(strlen(tmp) + 1);
            initial[i]=malloc(strlen(tmp) + 1);
            email[i]=malloc(strlen(tmp) + 1);
            classe[i]=malloc(strlen(tmp) + 1);
            fscanf(file,"%[^;];%[^;];%[^;];%[^;];%d;%s\n", nom[i],prenom[i],initial[i],email[i],&num_tel[i],classe[i]);
            if ((c=strrchr(classe[i],'\n')) != NULL) *c='\0';
            add_eleve(debut,buildEleve(nom[i],prenom[i],initial[i],email[i],num_tel[i],classe[i]));
         }
     fclose (file);
     free(file);
     for(i=0;i<28;i++)
        {
            free(nom[i]);
            nom[i] = NULL;
            free(prenom[i]);
            prenom[i] = NULL;
            free(initial[i]);
            initial[i] = NULL;
            free(email[i]);
            email[i] = NULL;
            free(classe[i]);
            classe[i] = NULL;
         }
       free(nom);
       free(prenom);
       free(initial);
       free(email);
       free(num_tel);
       free(classe);
       free(c);
       return debut;
}
int main()
{
    ELEVE *liste = malloc(sizeof(ELEVE));
    liste = load_fichier("liste.csv");
    free(liste);
    return 0;
}

La fonction build_eleve prend les info pris dans le fichier grâce aux fscanf et les place dans un pointeur de structure ELEVE.
Ensuite la fonction add_eleve va rajouté ce pointeur à la liste.

Merci.

14/10/2012, 03h49
Invité
Bonsoir,

Attention aux fuite de mémoires :
Code:

1 2 ELEVE *liste = malloc(sizeof(ELEVE)); liste = load_fichier("liste.csv");
Code:

1 2 ELEVE *current = malloc(sizeof(ELEVE)); current = debut->next;
Tu alloues un espace mémoire, mais le fais pointer vers un autre juste après.

Dans la fonction load_fichier() :
- Quel est le rôle de char tmp[50]; ?
  Tu ne l'initialises pas, et pourtant tu lui demandes sa longueur avec strlen.
- Tu n'es pas obligé de te trimballer avec autant de tableaux de pointeurs. De simples tableaux statiques servant pour UNE itération simplifieraient grandement la chose.
free(liste); : Là tu ne libères pas toute la mémoire allouée. Utilise une fonction free_list() qui va parcourir ta liste et libérer tous tes ELEVE.

En plus des remarques de Winjerome :
La fonction load_fichier() fait une sacrée salade et est à revoir complètement.
Parmi les anomalies
Code:

1 2 3 4 5 6 7 8 9 10 char *nom[15]; char *prenom[15]; char *initial[5]; char *email[30]; unsigned int *num_tel=malloc(29 * sizeof(unsigned int)); char *classe[15]; for(i=0;i<28;i++) { nom[i]=malloc(strlen(tmp) + 1); .....
i varie de 0 à 27 et nom a des indices limités à 14. On sort du tableau. Et de même pour la suite du code

Citation:

free(nom);
free(prenom);
free(initial);
free(email);
...
free(classe);
free(c);

n'ont pas été alloués dynamiquement,mais automatiquement, donc ne doivent pas être libérés par free()

Tout d'abord merci de prendre la peine de m'aider.

Je pense avoir bien corriger les erreurs que tu m'as dis mais malheureusement ça plante encore.

Voici mon code actuel:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct DATA{
   char nom[15];
   char prenom[15];
   char initial[5];
   char email[30];
   unsigned int num_tel;
   int taille;
   char classe[15];
   struct DATA *next;
   struct DATA *previous;
};
typedef struct DATA ELEVE;
void init_list(ELEVE *debut)
{
    debut->num_tel = 0;
    debut->taille = 0;
    debut->next = NULL;
    debut->previous = NULL;
}
void add_eleve(ELEVE *debut, ELEVE *nouveau)
{
    if (debut->taille == 0)
       {
           debut->taille = 1;
           debut->next = nouveau;
           nouveau->previous = debut;
       }
       else{
               ELEVE *current = debut->next;
               int i;
               for(i=1;i<debut->taille;i++)
                  {
                      current=current->next;
                  }
                current->next = nouveau;
                nouveau->previous = current;
                debut->taille++;
                nouveau->taille = debut->taille;
            }
}
ELEVE *buildEleve (char nom[15],char prenom[15],char initial[5],char email[30],unsigned int num_tel,char classe[15])
{
    ELEVE *data=malloc(sizeof(ELEVE));
    init_list(data);
    strcpy(data->nom,nom);
    strcpy(data->prenom,prenom);
    strcpy(data->initial,initial);
    strcpy(data->email,email);
    data->num_tel=num_tel;
    strcpy(data->classe,classe);
    return data;
}
ELEVE *load_fichier(char *path)
{
    ELEVE *debut = malloc(sizeof(ELEVE));
    init_list(debut);                                            //initialisation de la liste
    char *c;
    int i;
    FILE *file = fopen(path,"r");
    if(file==NULL)
       {
           printf("\n impossible d'ouvrir le fichier \n\n");
           return 0;
       }
    char nom[15];
    char prenom[15];
    char initial[5];
    char email[30];
    unsigned int num_tel;
    char classe[15];
    for(i=0;i<28;i++)
        {
            fscanf(file,"%[^;];%[^;];%[^;];%[^;];%d;%s\n", nom,prenom,initial,email,&num_tel,classe);
            if ((c=strrchr(classe,'\n')) != NULL) *c='\0';
            add_eleve(debut,buildEleve(nom,prenom,initial,email,num_tel,classe));
            memset (nom, 0, sizeof (nom));
            memset (prenom, 0, sizeof (prenom));
            memset (initial, 0, sizeof (initial));
            memset (email, 0, sizeof (email));
            memset (classe, 0, sizeof (classe));
         }
     fclose (file);
     free(file);
     free(c);
 
     return debut;
}
void list_delete(ELEVE *list)
{
    if (list != NULL)
    {
        ELEVE *p_tmp = list->next;
        while (p_tmp != NULL)
        {
            ELEVE *p_del = p_tmp;
            p_tmp = p_tmp->next;
            free(p_del);
        }
        free(list), list = NULL;
    }
}
int main()
{
    ELEVE *liste = load_fichier("liste.csv");
    list_delete(liste);
    return 0;
}

Bonjour,

Tu ne vérifies pas que tes malloc aient bien fonctionné.

Code:

fscanf(file,"%[^;];%[^;];%[^;];%[^;];%d;%s\n", nom,prenom,initial,email,&num_tel,classe);

Tu ne vérifies pas la taille de ce que tu lis.
Code:

1 2 3 4 5 memset (nom, 0, sizeof (nom)); memset (prenom, 0, sizeof (prenom)); memset (initial, 0, sizeof (initial)); memset (email, 0, sizeof (email)); memset (classe, 0, sizeof (classe));
A quoi te sert memset ?
Code:

1 2 free(file); free(c);
fclose, se charge de tout, il ne faut pas faire de free(file).
strrchr renvois un pointeur sur un caractère de ta chaîne, il n'y a donc pas eu d'allocation. Inutile de faire un free.

Si tu as une erreur lors de l'ouverture du fichier, tu as aussi une fuite de mémoire.

Sinon c'est un peu bizarre d'avoir des maillons qui soient eux-même des listes.
Pourquoi ne pas créer une structure liste qui contienne un pointeur sur le début et sur la fin de ta liste (cela t'éviterais pas mal de parcours) ainsi que la taille de ta liste au lieu d'avoir un champ dans chaque maillon qui n'est utilisé que par le premier maillon.

14/10/2012, 11h09
toufik135

re

Oui, je ne vérifie pas la taille de ce que je lis ( je devrai faire ça) mais je connais la taille des caractère en regarde le fichier .csv et j'ai choisi des char un peu plus grand exprès (exemple char nom[15], il n'y a aucune nom de + de 12 caractères).

J'ai corrigé le programme après les remarques de Winjerome (je l'ai posté, c'est mon 2ème commentaire) et je n'utilise plus de pointeur de tableau. J'utilise les malloc que pour allouer les pointeurs de structure si c'est pas ça ke tu veux me dire alors je comprend pas, peux tu me donner un exemple.

Avec fscanf, je lis une ligne du fichier .csv et les place dans chaque chaine de caractère (nom,prenom,initial,email,...).
Donc une itération correspond à une ligne et vu qu'à chaque ligne lue, on les place dans les chaines de caractère, il faut vider les chaines pour pouvoir y réécrire, c'est pour cela que j'utilise memset...mauvais choix?
14/10/2012, 11h20
Neckara

Citation:

Envoyé par toufik135

J'ai corrigé le programme après les remarques de Winjerome (je l'ai posté, c'est mon 2ème commentaire) et je n'utilise plus de pointeur de tableau. J'utilise les malloc que pour allouer les pointeurs de structure si c'est pas ça ke tu veux me dire alors je comprend pas, peux tu me donner un exemple.

Si tu as lu la première version de mon post avant que je n'édite quelques secondes après, n'en tiens pas compte j'étais passé un peu trop vite dessus.

Citation:

Envoyé par toufik135

Avec fscanf, je lis une ligne du fichier .csv et les place dans chaque chaine de caractère (nom,prenom,initial,email,...).
Donc une itération correspond à une ligne et vu qu'à chaque ligne lue, on les place dans les chaines de caractère, il faut vider les chaines pour pouvoir y réécrire, c'est pour cela que j'utilise memset...mauvais choix?

Non, on ne peut pas "vider" une chaîne de caractère, on ne peut que la lire ou réécrire par dessus. Lors du prochain appel à fscanf, tu va tout simplement réécrire par dessus, pas besoin de memset.

Voici mon code actuel:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct DATA{
   char nom[15];
   char prenom[15];
   char initial[5];
   char email[30];
   unsigned int num_tel;
   int taille;
   char classe[15];
   struct DATA *next;
   struct DATA *previous;
};
typedef struct DATA ELEVE;
 
void init_list(ELEVE *debut)
{
    debut->num_tel = 0;
    debut->taille = 0;
    debut->next = NULL;
    debut->previous = NULL;
}
void add_eleve(ELEVE *debut, ELEVE *nouveau)
{
    if (debut->taille == 0)
       {
           debut->taille = 1;
           debut->next = nouveau;
           nouveau->previous = debut;
       }
       else{
               ELEVE *current = debut->next;
               int i;
               for(i=1;i<debut->taille-1;i++)
                  {
                      current=current->next;
                  }
                current->next = nouveau;
                nouveau->previous = current;
                debut->taille++;
                nouveau->taille = debut->taille;
            }
}
ELEVE *buildEleve (char nom[15],char prenom[15],char initial[5],char email[30],unsigned int num_tel,char classe[15])
{
    ELEVE *data=malloc(sizeof(ELEVE));
    init_list(data);
    strcpy(data->nom,nom);
    strcpy(data->prenom,prenom);
    strcpy(data->initial,initial);
    strcpy(data->email,email);
    data->num_tel=num_tel;
    strcpy(data->classe,classe);
    return data;
}
ELEVE *load_fichier(char *path)
{
    ELEVE *debut = malloc(sizeof(ELEVE));
    init_list(debut);                                            //initialisation de la liste
    char *c;
    int i;
    FILE *file = fopen(path,"r");
    if(file==NULL)
       {
           printf("\n impossible d'ouvrir le fichier \n\n");
           return 0;
       }
    char nom[15];
    char prenom[15];
    char initial[5];
    char email[30];
    unsigned int num_tel;
    char classe[15];
    for(i=0;i<28;i++)
        {
            fscanf(file,"%[^;];%[^;];%[^;];%[^;];%d;%s\n", nom,prenom,initial,email,&num_tel,classe);
            if ((c=strrchr(classe,'\n')) != NULL) *c='\0';
            add_eleve(debut,buildEleve(nom,prenom,initial,email,num_tel,classe));
            memset (nom, 0, sizeof (nom));
            memset (prenom, 0, sizeof (prenom));
            memset (initial, 0, sizeof (initial));
            memset (email, 0, sizeof (email));
            memset (classe, 0, sizeof (classe));
         }
     fclose (file);
     return debut;
}
void list_delete(ELEVE *list)
{
    if (list != NULL)
    {
        ELEVE *p_tmp = list->next;
        while (p_tmp != NULL)
        {
            ELEVE *p_del = p_tmp;
            p_tmp = p_tmp->next;
            free(p_del);
        }
        free(list), list = NULL;
    }
}
int main()
{
    ELEVE *liste = load_fichier("liste.csv");
    list_delete(liste);
    return 0;
}

14/10/2012, 11h26
toufik135

re

Ah ok, je pensais qu'il allait débordé et pas réécrire dessus donc ça va, j'ai enlevé les memset.

Ca plante encore, il y a beaucoup d'erreurs décidément lol.

Des autres idées?

Merci.
14/10/2012, 11h29
Neckara

Tu peux utiliser un débogueur ou mettre des printf un peu partout pour identifier la ligne qui plante.

Ce sera plus facile pour nous de trouver l'origine de l'erreur après.

J'ai pas de linux et je suis même encore habitué à programmer en c sur linux (alors que c'est mieux je sais :s)
Donc j'utilise le debogger de codeblocks sur windows et il me dit juste un segmentation fault à l'adresse inconnue --> ??

J'ai donc mis des printf comme conseillé (dans la boucle for, et je remarqué que le programme plante après la 4ème itération) --> il print la 3 fois et puis plante.
Je l'ai inséré comme voici:
Code:

1 2 3 4 5 6 7 8 for(i=0;i<28;i++) { fscanf(file,"%[^;];%[^;];%[^;];%[^;];%d;%s\n", nom,prenom,initial,email,&num_tel,classe); if ((c=strrchr(classe,'\n')) != NULL) *c='\0'; printf("\n\n la"); // printf pour debugger add_eleve(debut,buildEleve(nom,prenom,initial,email,num_tel,classe)); }

14/10/2012, 11h49
Neckara

Code:

if ((c=strrchr(classe,'\n')) != NULL) *c='\0';

Est inutile, vu que tu lis classe avec "%s" donc tu es sûr qu'il n'y aura pas de '\n' dedans.

Ta fonction semble planter ici :

Code:

add_eleve(debut,buildEleve(nom,prenom,initial,email,num_tel,classe));

Met un printf à la fin de buildEleve pour savoir si c'est cette fonction qui plante ou non.
Met aussi des printfs un peu partout dans add_eleve ou dans buildEleve pour savoir quelle est la ligne qui plante.
Pense aussi à afficher les valeur de nom, prenom, initial, email, num_tel et classe avant l'appel à add_eleve pour vérifier que tu ais bien lu les données.

Sinon, fscanf retourne quelque chose, il faut donc vérifier son code de retour en cas d'erreur.
14/10/2012, 12h09
toufik135

re

Voilà, ça marche. :D

Un grand merci à toi Neckera, mais aussi à Winjerome et diogene.
Heureusement que ce genre de forum existe.

Le problème venait de la lecture du fichier .csv avec le fscanf.
La première ligne contenait le mot Mobile pour le numéro de téléphone et donc il prenait un char alors que num_tel est un unsigned int.
Il y avait aussi une autre erreur ou à un endroit il n'y avait pas de donné et donc je n'avais pas fait de condition pour vérifié cela.

Passez une excellente journée et merci! :ccool:
02/11/2012, 22h27
FIZA1

Salut toufik135

ça va?

En fait, j'ai vu ici ton code sur les listes chaînées. Pourrais tu, s'il te plaît si ça ne te dérange pas, me le passé?

Je l'ai vraiment besoin.

Merci d'avance.

Fiza