IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Problème liste chainée simple


Sujet :

C

  1. #1
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    19
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 19
    Par défaut Problème liste chainée simple
    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 :'(

  2. #2
    Membre Expert
    Avatar de kwariz
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Octobre 2011
    Messages
    898
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Chef de projet en SSII
    Secteur : Conseil

    Informations forums :
    Inscription : Octobre 2011
    Messages : 898
    Par défaut
    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)

  3. #3
    Membre confirmé
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Février 2012
    Messages
    149
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2012
    Messages : 149
    Par défaut re
    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;
    }

  4. #4
    Modérateur
    Avatar de gangsoleil
    Homme Profil pro
    Manager / Cyber Sécurité
    Inscrit en
    Mai 2004
    Messages
    10 150
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Manager / Cyber Sécurité

    Informations forums :
    Inscription : Mai 2004
    Messages : 10 150
    Par défaut
    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/
    "La route est longue, mais le chemin est libre" -- https://framasoft.org/
    Les règles du forum

  5. #5
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    19
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 19
    Par défaut 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 : 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++;
    }

  6. #6
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    19
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 19
    Par défaut
    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 ..

  7. #7
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    19
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 19
    Par défaut merci !!
    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 !!!

  8. #8
    Membre Expert
    Avatar de kwariz
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Octobre 2011
    Messages
    898
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Chef de projet en SSII
    Secteur : Conseil

    Informations forums :
    Inscription : Octobre 2011
    Messages : 898
    Par défaut
    N'oublies pas de gérer aussi la libération de la mémoire ... c'est important.

  9. #9
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    19
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 19
    Par défaut merci


    Juste ....

  10. #10
    Modérateur
    Avatar de gangsoleil
    Homme Profil pro
    Manager / Cyber Sécurité
    Inscrit en
    Mai 2004
    Messages
    10 150
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Manager / Cyber Sécurité

    Informations forums :
    Inscription : Mai 2004
    Messages : 10 150
    Par défaut
    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 */
      /* ... */
    "La route est longue, mais le chemin est libre" -- https://framasoft.org/
    Les règles du forum

  11. #11
    Membre confirmé
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Février 2012
    Messages
    149
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2012
    Messages : 149
    Par défaut 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?

  12. #12
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    19
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 19
    Par défaut à 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 =)

  13. #13
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    19
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 19
    Par défaut 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 ...

  14. #14
    Modérateur
    Avatar de gangsoleil
    Homme Profil pro
    Manager / Cyber Sécurité
    Inscrit en
    Mai 2004
    Messages
    10 150
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Manager / Cyber Sécurité

    Informations forums :
    Inscription : Mai 2004
    Messages : 10 150
    Par défaut
    Citation Envoyé par toufik135 Voir le message
    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 Voir le message
    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.
    "La route est longue, mais le chemin est libre" -- https://framasoft.org/
    Les règles du forum

  15. #15
    Membre très actif
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2010
    Messages
    434
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Janvier 2010
    Messages : 434
    Par défaut
    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

  16. #16
    Membre confirmé
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Février 2012
    Messages
    149
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2012
    Messages : 149
    Par défaut à jouana
    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)

  17. #17
    Modérateur
    Avatar de gangsoleil
    Homme Profil pro
    Manager / Cyber Sécurité
    Inscrit en
    Mai 2004
    Messages
    10 150
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Manager / Cyber Sécurité

    Informations forums :
    Inscription : Mai 2004
    Messages : 10 150
    Par défaut
    Citation Envoyé par Tziboun Voir le message
    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 */
    .......
    "La route est longue, mais le chemin est libre" -- https://framasoft.org/
    Les règles du forum

  18. #18
    Membre très actif
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2010
    Messages
    434
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Janvier 2010
    Messages : 434
    Par défaut
    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

  19. #19
    Membre Expert
    Avatar de kwariz
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Octobre 2011
    Messages
    898
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Chef de projet en SSII
    Secteur : Conseil

    Informations forums :
    Inscription : Octobre 2011
    Messages : 898
    Par défaut
    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.

  20. #20
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    19
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 19
    Par défaut 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 : 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++;
    }

Discussions similaires

  1. liste chaine simple
    Par el baz dans le forum C
    Réponses: 8
    Dernier message: 03/08/2007, 20h54
  2. Problème Listes chainées Structure contenant
    Par loco_info dans le forum C
    Réponses: 3
    Dernier message: 17/05/2007, 13h08
  3. un probléme de liste chainé simple
    Par seifdev dans le forum C
    Réponses: 15
    Dernier message: 02/04/2007, 16h36
  4. problème liste chainée
    Par jonjon83 dans le forum C
    Réponses: 11
    Dernier message: 28/02/2007, 18h58
  5. Problème Liste chainée
    Par skyangel dans le forum C++
    Réponses: 16
    Dernier message: 07/06/2006, 13h14

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo