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 :

Je ne vois pas l'erreur...


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    93
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 93
    Par défaut Je ne vois pas l'erreur...
    Ce bout de code doit décomposer une ligne de texte en mots.
    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
        int j=0,x=0;
       char * mot; /*pointeur sur le tableau contenant un mot */
     
        mot = malloc (2*sizeof(char)); /* creation du tableau dynamique pour le mot */
        if( mot == NULL )
        {
           fprintf(stderr,"Allocation impossible");
           exit(EXIT_FAILURE);
        }
     
        /* parcours de la ligne */
        for (j=0 ; j<=Tailleligne ; j++) {
            if(isspace(ligne[j]) || ispunct(ligne[j])) {  /*si espace OU ponctuation */
                if(nbAjout==0) {
                    MaChaine = inserer_debut(mot, Numligne);  /*Si premier ajout on sauvegarde le mot en tete */
                    nbAjout=100;
                }
                else{    MaChaine=inserer_fin(MaChaine, mot, Numligne); } /* Sinon on sauvegarde le mot en queue */
     
                free(mot); /* on detruit le mot */
                mot = malloc (2*sizeof(char)); /* creation de mot */
                if( mot == NULL )
                {
                   fprintf(stderr,"Allocation impossible");
                   exit(EXIT_FAILURE);
                }
     
                x=0; /* et c'est reparti pour un nouveau mot !! */
            }
            else    {
                mot[x]=ligne[j];    /* recuperation du caractère */
                mot = realloc (mot, x+1 *(2*sizeof(char)));  /* Ajout d'un element au tableau */
                printf(" mot[%d] = %c \n", x , mot[x] );    
                x++; /* et on reboucle */
     
            }
        }
    alors jai fait le teste sur la chaîne : "Je teste ma restitution et mon code de merde car je suis un mauvais."

    Jai comparé le mot qui a été lu et le mot qui a été stocké et Ô surprise :
    mot[0] = J
    mot[1] = e MotLu: Je ; Mot stocké: Je

    ca marche jusqu'à "restitution"
    mot[0] = r
    mot[1] = e
    mot[2] = s
    mot[3] = t
    mot[4] = i
    mot[5] = t
    mot[6] = u
    mot[7] = t
    mot[8] = i
    mot[9] = o
    mot[10] = n MotLu: restitution ; Mot stocké: restitution

    "et", "mon", cette partie est OK
    Mais à partir de là ça se gate un peu...

    mot[0] = c
    mot[1] = o
    mot[2] = d
    mot[3] = e MotLu: codeitution ; Mot stocké: codeitution

    niii?? o__O

    Apres je retrouve le même genre de chose pour les mots dépassant les 3 caractères... : merdetution, suisetution, mauvaistion
    (...)
    Il ne devrait rien rester de "restitution" puisqu'à chaque fois je libère mon espace mémoire free(mot). Je suis un peu perdu là...
    Merci pour votre aide.

  2. #2
    Membre émérite
    Profil pro
    Inscrit en
    Octobre 2004
    Messages
    633
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2004
    Messages : 633
    Par défaut
    Bonjour,
    Une piste : quelle dimension penses-tu réserver pour ton *char quand tu fais
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    mot = malloc (2*sizeof(char));

  3. #3
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    93
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 93
    Par défaut
    Un caractère plus le caractère fin de chaîne.

  4. #4
    Membre confirmé
    Profil pro
    Inscrit en
    Avril 2006
    Messages
    163
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2006
    Messages : 163
    Par défaut
    Remet ta chaine à blanc déjà ça évitera que tu garde les autres mots que tu as déjà découpé.

    Et sinon, j epense qu etu pourrais simplifier ton code en creant une deuxieme varaible ou alors en creant des indices de départ et de fin.

  5. #5
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    93
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 93
    Par défaut
    La chaine ligne est parfaite dans son contenu, les indices pour "mot" le sont aussi et je ne comprend pas pourquoi même en faisant free(mot), j'ai encore des traces de "restitution".

  6. #6
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par nunurs83
    La chaine ligne est parfaite dans son contenu, les indices pour "mot" le sont aussi et je ne comprend pas pourquoi même en faisant free(mot), j'ai encore des traces de "restitution".
    free() n'efface rien. Il libère, c'est tout.

  7. #7
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par nunurs83
    Ce bout de code doit décomposer une ligne de texte en mots.
    Code incomplet intestable...

  8. #8
    Membre Expert
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    Mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : Mars 2006
    Messages : 2 635
    Par défaut
    Utilise "calloc" qui initialise la zone mémoire à 0, ça donnera d'office une chaine valide.

  9. #9
    Membre confirmé
    Inscrit en
    Mai 2004
    Messages
    103
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 103
    Par défaut
    a quel moment tu insères le caractère fin de chaîne ?

  10. #10
    Rédacteur/Modérateur
    Avatar de Trap D
    Profil pro
    Inscrit en
    Septembre 2003
    Messages
    4 942
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2003
    Messages : 4 942
    Par défaut
    Le malloc se contente de fournir une adresse mémoire libre, il ne nettoie rien, il fournit une adresse d'au moins la taille demandée.
    Donc lorsque tu fais ton malloc, il te fournit peut-être la zone que tu viens de libérer où il reste ce que tu avais précédemment écrit, et comme tu écris un seul caractère sans mettre le zéro terminal après, tu retrouves ce que tu avais écris.

    D'autre part, es-tu sûr de ça ??
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    mot = realloc (mot, x+1 *(2*sizeof(char)));
    pourquoi
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    + 1 * (2 * sizeof(char)) ???
    Tu peux faire simplement + 2 car par définition sizeof(char) = 1
    "La haine seule fait des choix" - Koan Zen
    "Il ne faut pas être meilleur que les autres, il faut être meilleur que soi." Albert Jacquard
    "Ceux qui savent où ils ont posé leur parapluie ne sont pas alcooliques." - pgibonne.
    Faites du Prolog, ça vous changera les idées !
    Ma page Prolog
    Mes codes sources commentés

    Mon avatar : La Madeleine à la veilleuse de Georges de La Tour

  11. #11
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    93
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 93
    Par défaut
    Citation Envoyé par Trap D
    Le malloc se contente de fournir une adresse mémoire libre, il ne nettoie rien, il fournit une adresse d'au moins la taille demandée.
    Donc lorsque tu fais ton malloc, il te fournit peut-être la zone que tu viens de libérer où il reste ce que tu avais précédemment écrit, et comme tu écris un seul caractère sans mettre le zéro terminal après, tu retrouves ce que tu avais écris.

    D'autre part, es-tu sûr de ça ??
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    mot = realloc (mot, x+1 *(2*sizeof(char)));
    pourquoi
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    + 1 * (2 * sizeof(char)) ???
    Tu peux faire simplement + 2 car par définition sizeof(char) = 1
    exact je viens de rajouter la ligne mot[x] = '\0'; et maintenant ca marche
    et jai changé mes malloc et realloc
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    mot = realloc (mot, (x+1)*(sizeof(char)))
    mot = malloc (sizeof(char));
    x represente le dernier indice de mon tableau donc sa taille et si je veux rajouter une case je suis obligé de mettre "x+1"

  12. #12
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    93
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 93
    Par défaut
    Citation Envoyé par Emmanuel Delahaye
    Code incomplet intestable...
    tu veux vraiment voir la gueule de tout mon code ?

  13. #13
    Membre Expert

    Homme Profil pro
    Inscrit en
    Juillet 2003
    Messages
    2 075
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ardennes (Champagne Ardenne)

    Informations forums :
    Inscription : Juillet 2003
    Messages : 2 075
    Par défaut
    Citation Envoyé par nunurs83
    tu veux vraiment voir la gueule de tout mon code ?
    Non simplement le nécessaire comme les entetes à rajouter par exemple et reformuler deux trois petites choses pour que l'on puisse le tester sur nos plateformes et tacher de t'aider dans ta bataille avec la mémoire.
    D'ailleurs on a souvent vu les problèmes se résoudre comme par miracle au moment de faire une version light du code pour la poster ici...

  14. #14
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par nunurs83
    tu veux vraiment voir la gueule de tout mon code ?
    Si tu veux de l'aide réelle, oui. Sinon, on reste dans le vague... Essaye quand même de simplifier au minimum qui montre le problème... Mais ça doit être compilable...

  15. #15
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    93
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 93
    Par défaut
    Bon je préviens de suite c'est pas du code de pro :/
    je vous ai mis en gras les parties qui poseraient problème
    Bon le but c'est de lire dans un fichier un texte puis de faire un index. Pour le moment je me suis limité à la lecture du fichier ligne pas ligne (on doit indiquer le numéro de ligne de chaque mot dans l'index), le découpage de cette ligne et le stockage du mot dans une liste chaînée (le void* est normal) . Je viens de m'apercevoir d'un chose si mon texte fait plus de 4 lignes... j'ai une belle erreur : *** glibc detected *** free(): invalid next size (fast): 0x0804a568 ***
    Abandon



    Programme principale : Prog.c
    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
    #include <stdio.h>  
    #include <stdlib.h>  
    #include <string.h>
    #include <ctype.h>
    #include "GestionChaine.c"
    #include "GestionFic.c"
     
    int main()
    {
       Maillon *MaChaine=NULL;
       Maillon *MaChaine_move=NULL;
       MaChaine = GestionFic(MaChaine);
     
         if(MaChaine) {  //on parcours la liste pour en afficher le contenu 
            for(MaChaine_move=MaChaine; MaChaine_move!=NULL; MaChaine_move=MaChaine_move->suivant)
              {
                printf("%s ",MaChaine_move->motchaine);
            }    
        }
        return(0);
    }
    La gestion de fichier : GestionFic.c
    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
    FILE *pf;
    /*----------------------------- Ouverture du ficher ----------------------------------------*/
    int ouvrir_fichier()
    {
       char nom_fichier[100];
    
        /* demander le nom du fichier a ouvrir  */
       printf("\n Donnez le nom du fichier a ouvrir : ");
       scanf("%s",&nom_fichier);
       printf("\n fichier a ouvrir -> %s",nom_fichier);
    
       /* tente d'ouvrir le fichier et afficher un message d'erreur si erreur a l'ouverture  */
       pf = fopen(nom_fichier, "r");
    
       if (pf==NULL) { printf("\n *** erreur ouverture du fichier %s ***\n", nom_fichier); return 0; }
       else { printf("\n ok, fichier %s ouvert \n",nom_fichier); return 1; };
    }
    
    /*----------------------------- Decoupage de la ligne -------------------------------------*/
     Maillon * DecoupeLigne(char *ligne, int Tailleligne, int nbAjout, Maillon *MaChaine, int Numligne)
     {
         int j=0,x=0,Indice=0;
        char *mot=NULL; /*pointeur sur le tableau contenant un mot */
    
         mot = malloc (sizeof(char)); /* creation du tableau dynamique pour le mot */
         if( mot == NULL )
         {
            fprintf(stderr,"Allocation impossible");
            exit(EXIT_FAILURE);
         }
         /*Pourquoi passer Tailleligne ?? pkoi pas strln(ligne) ?? je crois que ca bogue...a verifier qd meme*/
         /* parcours de la ligne */
         for (j=0 ; j<=Tailleligne ; j++) {
             if(isspace(ligne[j]) || ispunct(ligne[j])) 
             {  /*si espace OU ponctuation */
                 if(nbAjout==0) {
                    MaChaine = inserer_debut(mot, Numligne);  /*Si premier ajout on sauvegarde le mot en tete */
                     nbAjout=100;
                 }
                 else {    
                     MaChaine=inserer_fin(MaChaine, mot, Numligne); 
                 } /* Sinon on sauvegarde le mot en queue */
                 
                 free(mot);  /* on libere le pointeur */
                 mot=NULL;
                 mot=calloc ( 1 , sizeof(char) );
                 //mot = malloc (sizeof(char)); /* creation de mot */
                 if( mot == NULL )
                 {
                    fprintf(stderr,"Allocation impossible");
                    exit(EXIT_FAILURE);
                 }
                 x=0; /* et c'est reparti pour un nouveau mot !! */
                 mot[x] = '\0';
             }
             else    {
                 mot[x]=ligne[j];    /* recuperation du caractère */
                mot = realloc (mot, (x+1)*(sizeof(char)));  /* Ajout d'un element au tableau */
                  
                 x++; /* et on reboucle */
                 mot[x] = '\0';
             }
         }
         return (MaChaine);
     }
      
     /*----------------------------- Lecture Fichier --------------------------------------*/
     Maillon * Lecture_Fic(Maillon *MaChaine)
     {
        char car[2]={0}; /* chaine de char contenant une lettre + caractere fin de chaine soit 2 emplacements a reserver */
         char * ligne; /* pointeur sur ligne */
        int  i=0, Tailleligne=0, Numligne=1, j=0, nbAjout=0;
    
         ligne = malloc (sizeof(char)); /* creation de ligne */
         if( ligne == NULL )
         {
            fprintf(stderr,"Allocation impossible");
            exit(EXIT_FAILURE);
         }
    
         while (!feof(pf))
         {  /* remplir ligne pour qu'il contienne la ligne lue. */
             fgets(car, sizeof car, pf); /* lecture dans le fichier */    
           if(car[0]!='\n') /* si pas newligne (dc pas fin de ligne) */
             {
                 ligne[i]=car[0];
              ligne = realloc (ligne, (i+1) *(sizeof(char)) );  /* Ajout d'un element */ 
                i++;
                 //ligne[i]='\0';
              }
             else { 
                 Tailleligne=i;
                 //Numligne=1;
                MaChaine = DecoupeLigne(ligne, Tailleligne, nbAjout, MaChaine, Numligne); /* on decoupe la ligne */
                 nbAjout=100;
                 
                 free(ligne); /* on libère ligne */
                 ligne=NULL;
                 ligne=calloc ( 1 , sizeof(char) );
                 if( ligne == NULL )
                 {
                    fprintf(stderr,"Allocation impossible");
                    exit(EXIT_FAILURE);
                 }
                 i=0; /* et hop ! encore un tour... */
                 ligne[i]='\0';
                 Numligne++;
             }
         }
         return (MaChaine);
     }  
    
    /*----------------------------- Fermeture du ficher ----------------------------------------*/
    void fermer_fichier()
    {
        fclose(pf);
    }
    
    /*----------------------------- Gestion  Fichier ---------------------------------------*/
    Maillon * GestionFic(Maillon *MaChaine)
    {
        int i = 3;
       i = ouvrir_fichier();
       if(i==1) {MaChaine= Lecture_Fic(MaChaine);
                      fermer_fichier(); }
        return (MaChaine);
    }
    Gestion de ma liste chainée :GestionChaine.c
    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
    #include "ListRec.c"
     
    /* permet d'inserer un maillon au debut de la chaine */
    /* renvoie le nouveau cree */
    Maillon *inserer_debut(char *MotLu, int Numligne)
    {
          Maillon *vMaillon;
        /* on alloue la memoire pour le nouvel element */
        if((vMaillon = (Maillon *)malloc(sizeof(Maillon))) == NULL)
        {    perror("Allocation impossible");
            exit(EXIT_FAILURE);
        }
     
        /* Creation du tableau pour le mot */
        vMaillon->motchaine = malloc (strlen(MotLu)*sizeof(char));
        if( vMaillon->motchaine == NULL )
        {
            fprintf(stderr,"Allocation impossible pour motchaine");
            exit(EXIT_FAILURE);
        }
       /* on copie le mot pour le stocker */
        strcpy(vMaillon->motchaine, MotLu);
        /* on chaine avec le prochain element de la liste (l'ancien premier) */
        /* comme il s'agit du premier élément, il n'y a rien après */
          vMaillon->suivant = NULL;//NewMaillon;
          /* on renvoie notre element */
          return(vMaillon);
    }
     
     
    /* permet d'inserer la valeur val a la fin de la liste list */
    /* renvoie la nouvelle liste cree                          */
    Maillon *inserer_fin(Maillon *NewMaillon,/* int Taillemot,*/ char *MotLu, int Numligne)
    { Maillon *vMaillon;
      Maillon *vMaillon_move;
     
      /* on alloue la memoire pour le nouvel element */
      if((vMaillon = (Maillon *)malloc(sizeof(Maillon))) == NULL)
      { perror("malloc failed "); exit(1); }
     
        /* Creation du tableau pour le mot */
        vMaillon->motchaine = malloc (strlen(MotLu)*sizeof(char));
        if( vMaillon->motchaine == NULL )
        {
           fprintf(stderr,"Allocation impossible pour motchaine");
           exit(EXIT_FAILURE);
        }
     
         /* on copie le mot pour le stocker */
        strcpy(vMaillon->motchaine, MotLu);
     
     
      /* on chaine avec le prochain element de la liste (aucun car c'est le dernier) */
      vMaillon->suivant = NULL;
     
      if(NewMaillon == NULL)
      { /* la liste etait vide, on devient le premier element */
        return(vMaillon);
      } else {
        /* on parcourt la liste jusqu'au dernier element (celui qui pointe sur NULL) */
        for(vMaillon_move=NewMaillon;vMaillon_move->suivant!=NULL;vMaillon_move=vMaillon_move->suivant);
        /* le dernier element pointe maitenant sur le nouvel element */
        vMaillon_move->suivant = vMaillon;
        /* le premier element de la liste n'a pas change */
       return(NewMaillon);
      }
    }
    Ma structure : ListRec.c
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    /* la structure TMaillon */
    typedef struct TMaillon Maillon;
     
    struct TMaillon {
       void *motchaine; /* mot lu et stockee dans la liste chaînée */
       Maillon *suivant; /* adresse du prochain maillon de la liste chaînée */
    };
    Normalement il y a tout pour que ca marche.
    Si vous avez des questions je suis là :p

  16. #16
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    93
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 93
    Par défaut
    le code est compilable mais si vous voyez des choses du genre LC*ptrLigneColonne, vous pouvez les virer sans pb

  17. #17
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par nunurs83
    Ma structure : ListRec.c
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    /* la structure TMaillon */
    typedef struct TMaillon Maillon;
     
    struct TMaillon {
       void *motchaine; /* mot lu et stockee dans la liste chaînée */
       Maillon *suivant; /* adresse du prochain maillon de la liste chaînée */
    };
    Ce fichier devrait être un .h et être protégé contre les inclusions multiples :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    #ifndef H_LISTREC
    #define H_LISTREC
     
    /* ListRec.h */
    /* la structure TMaillon */
    typedef struct TMaillon Maillon;
     
    struct TMaillon {
       void *motchaine; /* mot lu et stockee dans la liste chaînée */
       Maillon *suivant; /* adresse du prochain maillon de la liste chaînée */
    };
     
    #endif /* guard */
    D'autre part, je ne sais pas où tu as appris à faire de la programmation modulaire, mais visiblement, tu n'as pas compris le principe.

    On inclus pas les fichiers C les un dans les autres. Jamais.

    Par contre, on créée des fichiers C et des fichier d'entêtes qui comprennent tout ce qu'il faut pour réaliser les interfaces (prototypes) des fonctions exportées.

    Ensuite, on inclus ces .h dans les fichiers de définitions des fonctions pour en garantir la cohérence et dans les fichiers qui en ont besoin.

    Enfin, ces fichiers .c sont réunis dans un projet qui sert à générer l'éxécutable via une compilation séparée de chaque .c et une édition de lien (link) en vue de produire le fichier exécutable.

    http://emmanuel-delahaye.developpez....ganiser_source
    http://emmanuel-delahaye.developpez.....htm#organiser

    Sinon, j'ai commencé à étudier un peu ton code. Je n'arrive pas à comprendre pourquoi le mécanisme de lecture de ligne est aussi compliqué.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    allouer une ligne de taille N
    lire la ligne de taille N
    TANT QUE la ligne est incomplète
       doubler N (N = N x 2)
       reallouer à N
       lire la ligne de taille N / 2 à partir de ligne + (N / 2)
    FIN TANT QUE
    Tu fais beaucoup de choses compliquées en même temps, mais tu n'en maitrises vraiment aucune. Je te conseille de repartir de 0 et de traiter les problèmes un par un, mais à fond.

    Commence par la lecture de fichier ligne par ligne avec ajustement automatique de la taille de la ligne.

    Pour le découpage, je conseille ceci (dans les .c, ignorer ce qui est au-dessus du trait /* ---- ... ---- */) :

Discussions similaires

  1. Je vois pas mes erreurs
    Par étoile de mer dans le forum Débuter
    Réponses: 13
    Dernier message: 25/09/2008, 15h10
  2. [ImageMagick] Utilisation de getimagesize : je ne vois pas l'erreur
    Par JavaAcro dans le forum Bibliothèques et frameworks
    Réponses: 12
    Dernier message: 22/06/2006, 21h42
  3. Je ne vois pas l'erreur:( qlq pourra m'aider !
    Par moonia dans le forum Langage
    Réponses: 23
    Dernier message: 18/05/2006, 14h55
  4. Beuggouillage...je vois pas l'erreur
    Par Force_Rouge dans le forum C
    Réponses: 3
    Dernier message: 29/03/2006, 11h12
  5. Clé etrangere erreur 150 mais je vois pas l'erreur
    Par HurtMarley dans le forum SQL Procédural
    Réponses: 3
    Dernier message: 03/05/2005, 16h57

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