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 :

lecture puis ecriture dans un fichier


Sujet :

C

  1. #1
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut lecture puis ecriture dans un fichier
    Bonjour,

    J'aimerais faire un programme en c qui lit dans un fichier texte des données puis qui reprend ces données et les ecris dans un autre fichier texte. J'arrive à lire les données mais pas à les réécrire dans un autre fichier. J'aurais besoin d'un coup de pouce.

    voici mon code :

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    char ** lecture_fichier(FILE *,char *);
    void afficher_lecture(char **);
     
    int main(void)
    {
     
    char tableau[20];
    FILE *f1;
    FILE *f3;
    char **matrice_lecture;
    char **matrice_ecriture;
     
    f1=fopen("f1.txt","r");
         if(f1==0){printf("Il n'y a pas de fichier f1");}
     
    matrice_lecture=lecture_fichier(f1,tableau);
     
    fclose(f1);
     
    /*f3=fopen("f3.txt","a");
    matrice_ecriture=lecture_fichier(f3,tableau);
     
    fclose(f3);
    */
     
    afficher_lecture(matrice_lecture);
     
    printf("\n\n");
    system("pause");
     
    }
     
    char ** lecture_fichier(FILE *f,char *t)
    {
     
    static char* p[6];
    int i;
     
         for(i=0;i<6;i++)
         {
                p[i]=(char*)malloc(24);
         }
     
         i=0;
         while(fgets(t,50,f)!=0)
         {
                strcpy(p[i],t);
                i++;
         }
     
    return(p);   
     
    }
     
    void afficher_lecture(char **m)
    {
         int i=0;
         while(i<6)
         {    
             printf("%s\n",m[i]);
             i++;
         }
    }
    le fichier texte en question est de la forme :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    DUPOND              2002
    MARTINI             2120
    DURANDAL            2206
    DUBESSON            1913
    YACA                1801
    SOLORA              2013
    apres avoir lu les données du fichier f1.txt, j'ai essayé de réutilisé ma fonction lecture_fichier pour les écrire dans le fichier f3.txt mais il m'affiche êM> à la place et il n'écris rien.

    En faite vu que les données sont écris dans la mémoire avec le malloc, il y a moyen de les récupérer pour les réécrire.

    merci d'avance

    tchao
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  2. #2
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    j'ai changé de stratégie et réecris une fonction ecriture_fichier avec un fputs mais le probleme est qu'il arrive à ecrire dans f3 une seule chaine, la derniere.
    Je comprend pas.

    mon code :

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    char ** lecture_fichier(FILE *,char *);
    char ** ecriture_fichier(FILE *,char *);
    void afficher(char **);
     
    int main(void)
    {
     
    char tableau[20];
    FILE *f1;
    FILE *f3;
    char **matrice_lecture;
    char **matrice_ecriture;
     
    f1=fopen("f1.txt","r");
         if(f1==0){printf("Il n'y a pas de fichier f1");}
     
    matrice_lecture=lecture_fichier(f1,tableau);
     
    fclose(f1);
     
    f3=fopen("f3.txt","a");
    matrice_ecriture=ecriture_fichier(f3,tableau);
    fclose(f3);
     
    afficher(matrice_ecriture);
     
    printf("\n\n");
    system("pause");
     
    }
     
    char ** lecture_fichier(FILE *f,char *t)
    {
     
    static char* p[6];
    int i;
     
         for(i=0;i<6;i++)
         {
                p[i]=(char*)malloc(24);
         }
     
         i=0;
         while(fgets(t,50,f)!=0)
         {
                strcpy(p[i],t);
                i++;
         }
     
    return(p);   
     
    }
     
    void afficher(char **m)
    {
         int i=0;
         while(i<6)
         {    
             printf("%s\n",m[i]);
             i++;
         }
    }
     
     
    char ** ecriture_fichier(FILE *f,char *t)
    {
     
    static char* p[6];
    int i=0;
     
         while(fputs(t,f)!=0)
         {
                strcpy(p[i],t);
                i++;
         }
     
    return(p);   
    }
    Et lorsque je veux afficher les valeurs écrites ( matrice_ecriture ), il m'affiche NULL.
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  3. #3
    Expert éminent sénior

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 603
    Détails du profil
    Informations personnelles :
    Âge : 66
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 603
    Points : 17 913
    Points
    17 913
    Billets dans le blog
    2
    Par défaut
    avant de te lancer dans des choses complexes, relis tes cours, et pratique sur un exemple simple
    "Un homme sage ne croit que la moitié de ce qu’il lit. Plus sage encore, il sait laquelle".

    Consultant indépendant.
    Architecture systèmes complexes. Programmation grosses applications critiques. Ergonomie.
    C, Fortran, XWindow/Motif, Java

    Je ne réponds pas aux MP techniques

  4. #4
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    Ca ca m'aide pas beaucoup, mais bon jvé m'en contenter pour l'instant.
    C'est déjà ce que je fais.
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  5. #5
    Expert éminent sénior

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 603
    Détails du profil
    Informations personnelles :
    Âge : 66
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 603
    Points : 17 913
    Points
    17 913
    Billets dans le blog
    2
    Par défaut
    bon je vais te donner quelques indications :

    1. Pourquoi 6 lignes en dur ? Tu sais que ton fichier ne contiendra que 6 lignes ?
      Si tu ne le sais pas, il faut les compter avant d'allouer

    2. En plus cela permet de ne pas avoir de variables statiques (fortement déconseillées)

    3. Même chose pour le 24. Pourquoi alloues-tu 24 alors que tu lis dans 50 ?

    4. Le retour de fgets n'est pas 0, mais NULL

    5. Pourquoi l'écriture aurait besoin d'utre chose que ce qui a été lu ?

    6. Pourquoi ne pas ressortir le nombre de lignes lues et le passer aux routines qui en ont besoin ?


    en gardant ton "esprit", je ferais ceci comme fonctions :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    ...
     
    matrice_lecture=lecture_fichier(f1, &nbr_lignes);
     
    ... 
     
    statut =ecriture_fichier(f3,matrice_lecture, nbr_lignes);
     
    .....
     
    afficher(matrice_ecriture, nbr_lignes);
    "Un homme sage ne croit que la moitié de ce qu’il lit. Plus sage encore, il sait laquelle".

    Consultant indépendant.
    Architecture systèmes complexes. Programmation grosses applications critiques. Ergonomie.
    C, Fortran, XWindow/Motif, Java

    Je ne réponds pas aux MP techniques

  6. #6
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    Pour la fonction fgets, j'ai mis 50 parce que lorsque je mettais 24, le programme ne voulais pas fonctionnais. D'ailleurs je n'ais pas compris pourquoi. Il ne tourne qu'avec 26 au minimum donc g mis plus pour etre a l'aise pour l'instant.

    Et puis,
    Pourquoi 6 lignes en dur ? Tu sais que ton fichier ne contiendra que 6 lignes ?
    Si tu ne le sais pas, il faut les compter avant d'allouer
    oui, le fichier f1 ne doit contenir que cela. Normalement je dois aussi avoir un fichier f2 d'apres l'énonncer, et concatener les deux dans le fichier f3 et puis trier par nom. Mais pour l'instant, je commence juste avec le f1.

    En plus cela permet de ne pas avoir de variables statiques (fortement déconseillées)
    C'est vrai, mais pour l'instant, je souhaite que le tout fonctionne, apres je m'interesserais au superflu. Ce n'est qu'un exercice. Ce n'est pas un programme pour la nasa. Je ne suis pas encore expert en c, je souhaite que mon prog tourne avant tout.

    Mais je ne comprend pas pourquoi la fonction fputs ne me réécris que la derniere chaine ? Le programme fonctionne bien pour la fonction fgets, pourquoi pas pour le fputs !!!
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  7. #7
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    Bon, je me suis servi de tes conseils souviron34. J'ai créer une fonction qui compte le nombres de lignes de mes fichiers.

    Maintenant, j'ai un autre soucis, c'est que dans ma fonction de lecture qui inscrit les caracteres dans la mémoire dynamique, le compilateur ne veut pas que je lui mette un argument nb pour la taille du tableau.

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    /********** Déclaration des prototypes **********/
     
    int nb_lignes(FILE *);
    char ** lecture_fichier(FILE *,char *,int nb);
    char ** ecriture_fichier(FILE *,char *);
    void afficher(char **);
     
    /********** Fonction main **********/ 
     
    int main(void)
    {
     
    char tableau[20];
    FILE *f1;
    FILE *f2;
    FILE *f3;
    char **matrice_lecture_f1;
    char **matrice_lecture_f2;
    char **matrice_ecriture;
    int nb1;
    int nb2;
     
    f1=fopen("f1.txt","r");
         if(f1==0){printf("Il n'y a pas de fichier f1.txt");}
     
    printf("Voici les chaines du fichier f1 qui vont etre recopiees dans le fichier f3 :\n\n");
    nb1=nb_lignes(f1);
    matrice_lecture_f1=lecture_fichier(f1,tableau,nb1);
     
    fclose(f1);
     
    f2=fopen("f2.txt","r");
         if(f2==0){printf("Il n'y a pas de fichier f2.txt");}
     
    printf("Voici les chaines du fichier f2 qui vont etre recopiees dans le fichier f3 :\n\n");
    nb2=nb_lignes(f2);
    matrice_lecture_f2=lecture_fichier(f2,tableau,nb2);
     
    fclose(f2);
     
    /*f3=fopen("f3.txt","a");
    matrice_ecriture=ecriture_fichier(f3,tableau);
    fclose(f3);
    */
     
    printf("\n");
    system("pause");
     
    }
     
    /********** Fonction qui compte le nombres de lignes de caractères des fichiers f1 et f2 **********/
     
    int nb_lignes (FILE *f)
    {
      int nb=0;
      int c;
     
      while ((c = fgetc(f)) != EOF)
      {
        if (c == '\n')
        {
          nb++;
        }
      }
      return nb;
    }
     
     
     
    /********** Fonction lecture qui lit les chaînes de caractères des fichiers f1 et f2 **********/
     
    char ** lecture_fichier(FILE *f,char *t,int nb)
    {
     
    static char* p[nb];
    static int i;
    static int x=0;
     
         for(i=x;i<nb;i++)
         {
                p[i]=(char*)malloc(24);
         }
     
         i=0;
         while(fgets(t,26,f)!=NULL)
         {
                strcpy(p[i],t);
                i++;
         }
         i=0;
         while(i<nb)
         {    
             printf("%s\n",p[i]);
             i++;
         }
    x=x+nb;
    return(p);   
     
    }
     
    /********** Fonction ecriture qui recopie les chaînes de caracères des fichiers f1 et f2 dans le fichier f3 **********/
     
    char ** ecriture_fichier(FILE *f,char *t)
    {
     
    static char* p[6];
    int i=0;
     
         while(fputs(t,f) != NULL)
         {    
             strcpy(p[i],t);
             i++;
         }
     
    return(p);   
    }
    Le compilateur me dit
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    storage size of 'p' isn't constant 
    size of variable 'p' is too large
    merci d'avance

    tchao
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  8. #8
    Expert éminent sénior

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 603
    Détails du profil
    Informations personnelles :
    Âge : 66
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 603
    Points : 17 913
    Points
    17 913
    Billets dans le blog
    2
    Par défaut


    Bon je te donne quelques lignes de reflexion et de conduite, mais tu n'as pas vraiment fais ce que je t'ai suggere, ni dnas le texte, ni dans l'esprit (relis tes cours). Le C ne s'improvise pas.... Il y a des regles et des cours...


    Juste une indication :

    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
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    /********** Déclaration des prototypes **********/
    
    int nb_lignes(FILE *, char *, int taille);
    char ** lecture_fichier(FILE *,char *, int taille, int nb);
    int ecriture_fichier(FILE *,char *, int taille, char **, int nb);
    void afficher(char **, int nb);
     
    /********** Fonction main **********/ 
     
    int main(void)
    {
     
    char tableau[20];
    FILE *f1;
    FILE *f2;
    FILE *f3;
    char **matrice_lecture_f1;
    char **matrice_lecture_f2;
    char **matrice_ecriture;
    int nb1;
    int nb2;
     
    f1=fopen("f1.txt","r");
         if(f1==0){printf("Il n'y a pas de fichier f1.txt");}
    
    printf("Voici les chaines du fichier f1 qui vont etre recopiees dans le fichier f3 :\n\n");
    nb1=nb_lignes(f1, tableau, 20);
    matrice_lecture_f1=lecture_fichier(f1,tableau,20, nb1);
    
    fclose(f1);
    
    f2=fopen("f2.txt","r");
         if(f2==0){printf("Il n'y a pas de fichier f2.txt");}
    
    printf("Voici les chaines du fichier f2 qui vont etre recopiees dans le fichier f3 :\n\n");
    nb2=nb_lignes(f2, tableau, 20);
    matrice_lecture_f2=lecture_fichier(f2,tableau,20,nb2);
    
    fclose(f2);
    
    /*f3=fopen("f3.txt","a");
    matrice_ecriture=ecriture_fichier(f3,tableau);
    fclose(f3);
    */
    
    printf("\n");
    system("pause");
     
    }
    
    /********** Fonction qui compte le nombres de lignes de caractères des fichiers f1 et f2 **********/
    
    int nb_lignes (FILE *f, char *tab, int taille)
    {
      int nb=0;
      int c;
    
    /*  while ((c = fgetc(f)) != EOF) IL  Y A PLUS SUR ET COURT !!! 
      {
        if (c == '\n')
        {
          nb++;
        }
      }
    */
      while ( fgets(tab, taille, f) != NULL )
           nb++ ;
    
      rewind(f);
    
      return nb;
    }
    
    
    
    /********** Fonction lecture qui lit les chaînes de caractères des fichiers f1 et f2 **********/
    
    char ** lecture_fichier(FILE *f,char *t,int taille, int nb)
    {
    char **p = NULL ;
    int       i, j ;
    
          if ( (p = malloc ( nb*sizeof(char *) )) == NULL )
              return p ;
    
         for(i=0;i<nb;i++)
         {
                p[i]=(char*)malloc(taille);
                if ( p[i] == NULL )
                  {
                      if ( i != 0 )
                        for ( j = 0 ; j < i ; j++ )
                           free(p[i]);
    
                      free(p);
                      return NULL ;       
                  }
         }
     
         i=0;
         while(fgets(t,taille,f)!=NULL)
         {
                strcpy(p[i],t);
                i++;
         }
    
    return(p); 
    }
     
    /********** Fonction ecriture qui recopie les chaînes de caracères des fichiers f1 et f2 dans le fichier f3 **********/
     
    int ecriture_fichier(FILE *f, char **p, int nb)
    {
     int i=0, s=0, ss=0;
      
         for ( i = 0 ; i < nb ; i++ )
         {
             if ( (s = fputs(p, f)) == EOF )
                ss = 1 ;
         }
    
    return(ss);   
    }

    Si tu ne comprends pas tout, demande...

    Mais je pense surtout qu'il faut que tu revises tes cours....

    "Un homme sage ne croit que la moitié de ce qu’il lit. Plus sage encore, il sait laquelle".

    Consultant indépendant.
    Architecture systèmes complexes. Programmation grosses applications critiques. Ergonomie.
    C, Fortran, XWindow/Motif, Java

    Je ne réponds pas aux MP techniques

  9. #9
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    Bon, il vrai que je ne comprend pas grand chose à votre code. Je suis pas expert en C. Et c'est bon j'ai compris qu'il fallait que je lise mes cours, pas besoin de le répéter encore une fois.
    Mais sans aucune once de méchanceté, je ne veux pas recopier votre code.
    J'ai commencé à taper le mien et j'aimerais le continuer.
    Et je pense que pour l'instant il fonctionne bien sauf pour l'écriture dans le fichier f3.txt. Je souhaiterais juste savoir pourquoi il recopie juste la derniere ligne.

    Est ce que la copie en mémoire ne fonctionne pas ?

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    /********** Déclaration des prototypes **********/
     
    int nb_lignes(FILE *);
    char ** lecture_fichier(FILE *,char *,int nb);
    char ** ecriture_fichier(FILE *,char *,int);
    void afficher(char **);
     
    /********** Fonction main **********/ 
     
    int main(void)
    {
     
    char tableau[20];
    FILE *f1;
    FILE *f2;
    FILE *f3;
    char **matrice_lecture_f1;
    char **matrice_lecture_f2;
    char **matrice_ecriture;
    int nb1;
    int nb2;
    int x;
     
    f1=fopen("f1.txt","r");
         if(f1==0){printf("Il n'y a pas de fichier f1.txt");}
     
    printf("Voici les chaines du fichier f1 qui vont etre recopiees dans le fichier f3 :\n\n");
    nb1=nb_lignes(f1);
    fclose(f1);
    f1=fopen("f1.txt","r");
    matrice_lecture_f1=lecture_fichier(f1,tableau,nb1);
    fclose(f1);
     
    f2=fopen("f2.txt","r");
         if(f2==0){printf("Il n'y a pas de fichier f2.txt");}
     
    printf("Voici les chaines du fichier f2 qui vont etre recopiees dans le fichier f3 :\n\n");
    nb2=nb_lignes(f2);
    fclose(f2);
    f2=fopen("f2.txt","r");
    matrice_lecture_f2=lecture_fichier(f2,tableau,nb2);
    fclose(f2);
     
    f3=fopen("f3.txt","a");
    matrice_ecriture=ecriture_fichier(f3,tableau,x);
    fclose(f3);
     
     
    printf("\n");
    system("pause");
     
    }
     
    /********** Fonction qui compte le nombres de lignes de caractères des fichiers f1 et f2 **********/
     
    int nb_lignes (FILE *f)
    {
      int nb=0;
      int c;
     
      while ((c = fgetc(f)) != EOF)
      {
        if (c == '\n')
        {
          nb++;
        }
      }
      return nb;
    }
     
     
     
    /********** Fonction lecture qui lit les chaînes de caractères des fichiers f1 et f2 **********/
     
    char ** lecture_fichier(FILE *f,char *t,int nb)
    {
     
    static char* p[20];
    static int i;
    static int x=0;
     
         for(i=x;i<x+nb;i++)
         {
             p[i]=(char*)malloc(24);
         }
     
    i=x;
         while(fgets(t,26,f)!=NULL)
         {
             strcpy(p[i],t);
             i++;
         }
    i=x;
         while(i<x+nb)
         {    
             printf("%s\n",p[i]);
             i++;
         }
     
    x=x+nb;
    return(p);
     
     
    }
     
    /********** Fonction ecriture qui recopie les chaînes de caracères des fichiers f1 et f2 dans le fichier f3 **********/
     
    char ** ecriture_fichier(FILE *f,char *t,int x)
    {
     
    static char* p[10];
    static int i=0;
     
         while(fputs(t,f) != NULL)
         {    
             strcpy(p[i],t);
             i++;
         }
    }
    C'est gentil de m'aider. Mais votre code ne se compile pas non plus sans utiliser la fonction écriture.
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  10. #10
    Membre averti Avatar de corentin59
    Profil pro
    Inscrit en
    Octobre 2006
    Messages
    462
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2006
    Messages : 462
    Points : 441
    Points
    441
    Par défaut
    Bonjour

    Pour commencer, plusieurs remarques sur ton code :
    1) Après l'ouverture du fichier f1 (ou f2), tu vérifies qu'il s'est bien ouvert. Sauf que si ce n'est pas le cas, tu te contentes d'afficher une phrase et après tu utilises quand même le pointeur f1 (ou f2) !!!!
    2) Dans ta fonction qui compte le nombre de lignes du fichier, le résultat retourné peut être faux : en fait tu ne compte pas le nombre de lignes mais le nombre de retour charriot. Ainsi, si la dernière ligne ne se termine pas par un retour charriot, elle ne sera pas comptabilisée. Ce que souviron34 te proposait est effectivement plus court et plus sûr. La fonction fgets permet de lire un nombre maximum de caractères jusqu'à ce qu'une fin de ligne soit rencontrée (http://www.cplusplus.com/reference/c...dio/fgets.html). La fonction rewind permet (entre autre) de réinitialiser le pointeur f1 (http://www.cplusplus.com/reference/c...io/rewind.html).

  11. #11
    Membre averti Avatar de corentin59
    Profil pro
    Inscrit en
    Octobre 2006
    Messages
    462
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2006
    Messages : 462
    Points : 441
    Points
    441
    Par défaut
    voici un code qui compile sans pb :

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    /* nombre maximum de caractères par ligne dans les fichiers lus */
    #define NBMAXCHARPARLIGNE 100
     
    /********** Déclaration des prototypes **********/
    int nb_lignes(FILE *,char *);
    char **lecture_fichier(FILE *,int);
    void ecriture_fichier(FILE *,char **,int,char **,int);
     
    /*********************************************************************************************************************/
    /* Fonction main                                                                                                     */
    /*********************************************************************************************************************/
    int main(void) {
    	FILE *f1, *f2, *f3;
    	char **matrice_lecture_f1, **matrice_lecture_f2;
    	char *ligne;
    	int i, nb1, nb2;
     
    	/* allocation du tableau de caractères qui servira à contenir les lignes des fichiers */
    	ligne=malloc(NBMAXCHARPARLIGNE);
    	if ( !ligne ) {
    		fprintf(stderr,"probleme allocation memoire\n");
    		fflush(stderr);
    		exit(0);
    	}
     
    	/* traitement du fichier f1.txt */
    	f1=fopen("f1.txt","r");
    	if ( !f1 ) {
    		fprintf(stderr,"l'ouverture du fichier \"f1.txt\" a echouee\n");
    		fflush(stderr);
    		exit(0);
    	}
    	printf("Voici les chaines du fichier \"f1.txt\" qui vont etre recopiees dans le fichier \"f3.txt\" :\n\n");
    	nb1=nb_lignes(f1,ligne);
    	matrice_lecture_f1=lecture_fichier(f1,nb1);
    	fclose(f1);
     
    	/* traitement du fichier f2.txt */
    	f2=fopen("f2.txt","r");
    	if ( !f2 ) {
    		fprintf(stderr,"l'ouverture du fichier \"f2.txt\" a echouee\n");
    		fflush(stderr);
    		exit(0);
    	}
    	printf("Voici les chaines du fichier \"f2.txt\" qui vont etre recopiees dans le fichier \"f3.txt\" :\n\n");
    	nb2=nb_lignes(f2,ligne);
    	matrice_lecture_f2=lecture_fichier(f2,nb2);
    	fclose(f2);
     
    	/* ecriture dans le fichier f3.txt */
    	f3=fopen("f3.txt","w");
    	if ( !f3 ) {
    		fprintf(stderr,"l'ouverture du fichier \"f3.txt\" a echouee\n");
    		fflush(stderr);
    		exit(0);
    	}
    	ecriture_fichier(f3,matrice_lecture_f1,nb1,matrice_lecture_f2,nb2);
    	fclose(f3);
     
    	/* liberation de la memoire */
    	free(ligne);
    	for (i=0;i<nb1;i++) {
    		free(matrice_lecture_f1[i]);
    	}
    	free(matrice_lecture_f1);
    	for (i=0;i<nb2;i++) {
    		free(matrice_lecture_f2[i]);
    	}
    	free(matrice_lecture_f2);
     
    	printf("\n");
    	system("pause");
    }
     
    /*********************************************************************************************************************/
    /* Fonction qui compte le nombres de lignes de caractères des fichiers f1 et f2                                      */
    /*********************************************************************************************************************/
    int nb_lignes (FILE *f,char *ligne) {
    	int nbligne=0;
     
    	/* lecture ligne par ligne du fichier */
    	while ( fgets(ligne,NBMAXCHARPARLIGNE,f) != NULL ) {
    		nbligne++;
    	}
     
    	/* reinitialisation du pointeur FILE (pour qu'il pointe a nouveau sur le premier element du fichier */
    	rewind(f);
     
    	return nbligne;
    }
     
    /*********************************************************************************************************************/
    /* Fonction lecture qui lit les chaînes de caractères des fichiers f1 et f2                                          */
    /*********************************************************************************************************************/
    char **lecture_fichier(FILE *f,int nb) {
    	char **mat=NULL;
    	int i, j;
     
    	/* allocation du tableau de lignes de caractères qui servira à contenir les lignes du fichier */
    	mat=malloc(sizeof(*mat)*nb);
    	if ( !mat ) {
    		fprintf(stderr,"probleme allocation memoire\n");
    		fflush(stderr);
    		exit(0);
    	}
    	for (i=0;i<nb;i++) {
    		mat[i]=malloc(NBMAXCHARPARLIGNE);
    		if ( !mat[i] ) {
    			fprintf(stderr,"probleme allocation memoire\n");
    			fflush(stderr);
    			exit(0);
    		}
    	}
     
    	/* lecture des lignes du fichier */
    	i=0;
    	while ( (i < nb) && (fgets(mat[i],NBMAXCHARPARLIGNE,f) != NULL) ) {
    		/* on supprime le retour chariot final, si il existe */
    		if ( mat[i][strlen(mat[i])-1] == '\n' ) {
    			mat[i][strlen(mat[i])-1] = '\0';
    		}
    		printf("ligne %d : \"%s\"\n",i+1,mat[i]);
    		i++;
    	}
     
    	/* verification que le nombre de lignes lues correspond a celui donne en parametre */
    	if ( i != nb ) {
    		printf("le nombre de lignes lues ne correspond pas à celui donné!!!\n");
    	}
     
    	return(mat);
    }
     
    /*********************************************************************************************************************/
    /* Fonction ecriture qui recopie les chaînes de caracères des fichiers f1 et f2 dans le fichier f3                   */
    /*********************************************************************************************************************/
    void ecriture_fichier(FILE *f,char **mat1, int nb1,char **mat2, int nb2) {
    	int i;
     
    	for (i=0;i<nb1;i++) {
    		fprintf(f,"%s\n",mat1[i]);
    	}
    	for (i=0;i<nb2;i++) {
    		fprintf(f,"%s\n",mat2[i]);
    	}
    }
    En sortie, il t'a bien généré un fichier f3 qui est la concaténation des deux fichiers f1 et f2.

  12. #12
    Membre averti Avatar de corentin59
    Profil pro
    Inscrit en
    Octobre 2006
    Messages
    462
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2006
    Messages : 462
    Points : 441
    Points
    441
    Par défaut
    Ce n'est vraiment pas loin de ce que t'avait donné souviron34 et certainement moins sûr (notamment en ce qui concerne la gestion de la mémoire en cas d'erreur). Avant tout commentaire, je pense qu'il faut que tu essaies de comprendre ce que fait le code et si ce n'est pas le cas, de poser des questions précises sur ce que tu ne comprend pas. je pense que ce que souviron34 voulait te dire dans ces remarques, c'est qu'il ne sert à rien de t'obstiner dans la voie que tu as choisie, si elle est dangereuse d'un point de vue codage ou simplement si elle ne fonctionne pas.

  13. #13
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Points : 5 360
    Points
    5 360
    Par défaut
    Voici ma contribution commentée aux corrections:

    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
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    #define NB_ELEMS(tableau) ( sizeof (tableau) / sizeof *(tableau) )
     
    /********** Déclaration des prototypes **********/
     
    size_t nb_lignes (FILE *f, size_t *);
    char ** lecture_fichier(FILE *, size_t , size_t);
    void ecriture_fichier(char ** matrice, FILE *f);
    void afficher(char **);
    void fclean(char *, FILE *);
    void detruire_matrice(char ***p_mat);
     
    /********** Fonction main **********/
     
    int main(void)
    {
        FILE *flecture= NULL;
        FILE *fecriture = NULL;
        char **matrice_lecture = NULL;
        int nlignes; /* -tc- nombre de ligne d'un fichier */
        size_t taille_lignes; /* -tc- taille max des lignes du fichier */
     
        char const *fichiers_a_lire[] =
        {
            "f1.txt",
            "f2.txt"
        };
        size_t i;
     
        for (i = 0; i < NB_ELEMS(fichiers_a_lire); i++)
        {
            flecture = fopen(fichiers_a_lire[i],"r");
            /* -tc- fopen() renvoie NULL en cas d'echec et pas 0 */
            if (flecture == NULL)
            {
                fprintf(stderr, "Il n'y a pas de fichier %s\n", fichiers_a_lire[i]);
                /* -tc- Si tu n'arrives pas a lire le fichier f1.txt, soit tu essaies
                   de te recuperer de l'erreur, soit tu quitte le programme */
                exit(EXIT_FAILURE);
            }
     
            nlignes = nb_lignes(flecture, &taille_lignes);
     
            /* -tc- pourquoi fermer et reouvrir f1, il suffit que nb_ligne replace
               l'indicateur de position a sa position initialise une fois le job
               termine
            fclose(f1);
            f1=fopen("f1.txt","r");
            */
            matrice_lecture = lecture_fichier(flecture, nlignes, taille_lignes);
            if (matrice_lecture != NULL)
            {
                fclose(flecture);
     
                afficher(matrice_lecture);
     
     
                fecriture = fopen("f3.txt", "a");
                if (fecriture == NULL)
                {
                    fprintf(stderr, "Impossible de creer ou d'ouvrir en ecriture "
                            "le fichier f3.txt\n");
                    exit(EXIT_FAILURE);
                }
                ecriture_fichier(matrice_lecture, fecriture);
                fclose(fecriture);
                /* -tc- n'oublie pas de liberer la memoire allouee pour la matrice */
                detruire_matrice(&matrice_lecture);
            }
        }
     
        return 0;
    }
     
    /********** Fonction qui compte le nombres de lignes de caractères des fichiers f1 et f2 **********/
     
    /* -tc- compte le nombre de ligne d'un fichier */
    size_t nb_lignes (FILE *f, size_t *ligne_max_long)
    {
        size_t nb=0;
     
        /* -tc- il est recommande de valider les arguments passes a la fonction */
        if (f != NULL)
        {
            int c;
            /* -tc- on profite du parcours du fichier pour determiner la longueur
               max des lignes */
            size_t lmax = 0;
            size_t longueur = 0;
            /* -tc- L'indicateur de position du fichier n'est pas necessairement
               positionne au debut du fichier. On memorise la position courante
               et on se rend au debut du fichier */
            long pos_init = ftell(f);
            if (pos_init != -1)
            {
                fseek(f, 0, SEEK_SET);
            }
     
            while ((c = fgetc(f)) != EOF)
            {
                if (c == '\n')
                {
                    if (longueur > lmax)
                    {
                        lmax = longueur;
                    }
                    longueur = 0;
                    nb++;
                }
                else
                {
                    longueur++;
                }
            }
     
            /* -tc- on replace l'indicateur de position à sa position initiale */
            if (pos_init != -1)
            {
                fseek(f, pos_init, SEEK_SET);
            }
     
            /* -tc- on retourne la taille de la ligne la plus longue */
            if (ligne_max_long != NULL)
            {
                *ligne_max_long = lmax;
            }
        }
        return nb;
    }
     
     
    /********** Fonction lecture qui lit les chaînes de caractères des fichiers f1 et f2 **********/
     
    /* -tc- ca ne sert a rien de passer le tampon pour la saisie en argument de
       ta fonction, la longeur des chaines etant definie en dur dans la definition
       du pointeur p */
    char ** lecture_fichier(FILE *f, size_t nb, size_t taille_lignes)
    {
     
        /* -tc- pourquoi toutes ces variables statiques ? En plus, si tu veux que
           p soit un pointeur sur un tableau de 20 char, la definition n'est pas
           correcte! Si p est de type pointeur sur un tableau de 20 chars, le type
           de retour de ta fonction est faux.
        static char* p[20];
        static int i;
        static int x=0;
        */
     
     
        char **p = NULL;
     
        if (f != NULL && nb > 0)
        {
            char *tampon = NULL;
            size_t taille_tampon = taille_lignes + 2;
     
            /* -tc- on alloue la memoire pour le tampon de saisie */
            tampon = malloc(taille_tampon * sizeof *tampon);
            if (tampon != NULL)
            {
                size_t i;
     
                /* -tc- attention a ne pas caster la valeur retournee par malloc(). Cela
                   peut mener a la castastrophe sur des systeme tels que Win64 */
                p = malloc((nb + 1) * sizeof *p);
                /* -tc- il faut TOUJOURS verifier la valeur retournee par malloc() */
                if (p != NULL)
                {
                    int err = 0;
     
                    for (i = 0; err == 0 && i < nb &&
                            fgets(tampon, taille_tampon, f) != NULL; i++)
                    {
                        fclean(tampon, f);
                        /* -tc- strdup() n'est pas standard, mais relativement
                           portable et relativement facile a implanter si necessaire */
                        p[i] = strdup(tampon);
                        if (p[i] == NULL)
                        {
                            /* -tc- si strdup ne parvient pas a allouer de la
                               memoire, on sort de la boucle et on fait le menage */
                            err = 1;
                        }
                    }
                    p[i] = NULL;
     
                    if (err != 0)
                    {
                        /* -tc- si on a une erreur d'allocation, on fait le menage! */
                        while (i > 0)
                        {
                            i--;
                            free(p[i]), p[i] = NULL;
                        }
                        free(p), p = NULL;
                    }
     
                    /* -tc- liberation de la memoire allouee pour le tampon */
                    free(tampon), tampon = NULL;
                }
            }
        }
        return p;
     
     
    }
     
    /********** Fonction ecriture qui recopie les chaînes de caracères des fichiers f1 et f2 dans le fichier f3 **********/
     
    void ecriture_fichier(char ** matrice, FILE *f)
    {
        if (matrice != NULL)
        {
            size_t i;
     
            for (i = 0; matrice[i] != NULL; i++)
            {
                fprintf(f, "%s\n", matrice[i]);
            }
        }
    }
     
    /* -tc- permet d'afficher le contenu d'une matrice */
    void afficher(char **matrice)
    {
        if (matrice != NULL)
        {
            ecriture_fichier(matrice, stdout);
        }
    }
     
    /* -tc- permet de liberer la memoire allouee pour la matrice */
    void detruire_matrice(char ***p_mat)
    {
        if (p_mat != NULL && *p_mat != NULL)
        {
            char **matrice = *p_mat;
            size_t i;
     
            for (i = 0; matrice[i] != NULL; i++)
            {
                free(matrice[i]);
            }
            free(matrice);
            *p_mat = NULL;
        }
    }
     
    /* -tc- elimine le caractere de fin de ligne saisi par fgets() et purge le tampon
       du flux entrant si necessaire */
    void fclean(char *tampon, FILE *fp)
    {
        if (tampon != NULL && fp != NULL)
        {
            char *pc = strchr(tampon, '\n');
     
            if (pc != NULL)
            {
                *pc = 0;
            }
            else
            {
                int c;
     
                while ((c = fgetc(fp)) != '\n' && c != EOF)
                {
                }
            }
        }
    }
    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  14. #14
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    merci pour ces programmes totalement complet même si ce n'est pas ce que je voulais car le travail a été fait par des experts en C. Je vais essayer de comprendre tout cela avec les moyens du bord.

    Je vous envoie quand même ce que j'avais fait jusque là. J'avais (enfin je pense) pris en compte les commentaires que vous aviez fait à mon code. Le seul probleme que j'avais à résoudre été de réécrire les données dans f3.

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    /********** Déclaration des prototypes **********/
     
    int nb_lignes(FILE *,int taille,char *);
    char ** lecture_fichier(FILE *,char *,int taille,int nb);
    char ** ecriture_fichier(FILE *,char *);
    void afficher(char **);
     
    /********** Fonction main **********/ 
     
    int main(void)
    {
     
    char tableau[10];
    FILE *f1;
    FILE *f2;
    FILE *f3;
    char **matrice_lecture_f1;
    char **matrice_lecture_f2;
    char **matrice_ecriture;
    int nb1;
    int nb2;
    int taille=26;
     
     
     
    f1=fopen("f1.txt","r");
         if(f1==0){perror("Erreur dans l'ouverture du fichier f1.txt");}
     
    printf("Voici les chaines du fichier f1 qui vont etre recopiees dans le fichier f3 :\n\n");
     
    nb1=nb_lignes(f1,taille,tableau);
    matrice_lecture_f1=lecture_fichier(f1,tableau,taille,nb1);
    fclose(f1);
     
    f2=fopen("f2.txt","r");
         if(f2==0){perror("Erreur dans l'ouverture du fichier f2.txt");}
     
    printf("Voici les chaines du fichier f2 qui vont etre recopiees dans le fichier f3 :\n\n");
     
    nb2=nb_lignes(f2,taille,tableau);
    matrice_lecture_f2=lecture_fichier(f2,tableau,taille,nb2);
    fclose(f2);
     
    f3=fopen("f3.txt","a");
    matrice_ecriture=ecriture_fichier(f3,tableau);
    fclose(f3);
     
    printf("\n");
    system("pause");
     
    }
     
    /********** Fonction qui compte le nombres de lignes de caractères des fichiers f1 et f2 **********/
     
    int nb_lignes (FILE *f,int taille, char *tab)
    {
    int nb=0;
     
      while ( fgets(tab,taille, f) != NULL )
          { 
              nb++ ;
          }
     
      rewind(f);
      return nb;
     
    }
     
     
     
    /********** Fonction lecture qui lit les chaînes de caractères des fichiers f1 et f2 **********/
     
    char ** lecture_fichier(FILE *f,char *t,int taille,int nb)
    {
     
    static char* p[10];
    static int i;
    static int x=0;
     
         for(i=x;i<x+nb;i++)
         {
             p[i]=(char*)malloc(taille);
         }
     
    i=x;
         while(fgets(t,taille,f)!=NULL)
         {
             strcpy(p[i],t);
             i++;
         }
    i=x;
         while(i<x+nb)
         {    
             printf("%s\n",p[i]);
             i++;
         }
     
    x=x+nb;
    return p;
     
     
    }
     
    /********** Fonction ecriture qui recopie les chaînes de caracères des fichiers f1 et f2 dans le fichier f3 **********/
     
    char ** ecriture_fichier(FILE *f,char *t)
    {
     
    static char* p[10];
    static int i=0;
     
         while(fputs(t,f) != NULL)
         {    
             strcpy(p[i],t);
             i++;
         }
    }
    J'ai compris pourquoi je devais aller jusqu'a 26 caracteres pour le fgets. C'était en faite 2 caracteres de plus que ce qu'il y avait dans le fichier pour le "/n", le retour chariot.
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  15. #15
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    Si vous savez pourquoi mon code ne fonctionnais par pour l'écriture cela m'aiderait pour comprendre mes erreurs. Mais sinon je vais essayer de comprendre ce que vous avez fait pour l'intégrer à mon code.

    Si j'ai un soucis de compréhension, je vous le dirait.
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  16. #16
    Expert éminent sénior

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 603
    Détails du profil
    Informations personnelles :
    Âge : 66
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 603
    Points : 17 913
    Points
    17 913
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par charlix Voir le message
    Si vous savez pourquoi mon code ne fonctionnais par pour l'écriture cela m'aiderait pour comprendre mes erreurs.
    C'est pourtant bien simple..

    RIEN dans la lecture ou l'écriture ne fait ce que tu penses que ça fait, et n'est correct, tant d'un point de vue sémantique que fonctionnel....

    D'où nos remarques...

    On est là pour aider, pas pour donner des cours.. Il y en a plein ici, et ailleurs..

    "Un homme sage ne croit que la moitié de ce qu’il lit. Plus sage encore, il sait laquelle".

    Consultant indépendant.
    Architecture systèmes complexes. Programmation grosses applications critiques. Ergonomie.
    C, Fortran, XWindow/Motif, Java

    Je ne réponds pas aux MP techniques

  17. #17
    Membre averti Avatar de corentin59
    Profil pro
    Inscrit en
    Octobre 2006
    Messages
    462
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2006
    Messages : 462
    Points : 441
    Points
    441
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    char ** ecriture_fichier(FILE *f,char *t)
    {
     
    static char* p[10];
    static int i=0;
     
         while(fputs(t,f) != NULL)
         {    
             strcpy(p[i],t);
             i++;
         }
    }
    Ce que fait cette fonction est vraiment curieux (c'est peut-être pour cela que ça ne marche pas ...)
    Déjà, elle est censée retourner une variable de type char** et il n'y a aucun "return" dans la fonction. Ensuite, tu considères que la valeur retournée par "fputs" peut être "NULL" alors que ce n'est pas le cas (http://www.cplusplus.com/reference/c...dio/fputs.html). Ensuite, tu copies t dans p[i] alors que ce dernier ne pointe vers aucun espace mémoire (je n'ai pas vu d'allocation). De plus, je ne vois pas à quoi sert cette opération car de toute manière, c'est toujours t que tu cherches à copier dans le fichier.

  18. #18
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    C'est vrai que la fonction ecriture n'était pas une réussite pour pas dire autre chose. Mais je ne l'avais pas encore modifiée sur ce post. J'en avais fait une autre dans un autre fichier.

    Enfin bon, j'ai trouvé l'erreur apres une longue réfléxion sur ce code. Et je me suis servi des modeles de test de vos codes pour une bonne utilisation du programme pour la gestion de la mémoire. tout fonctionne bien.

    merci pour votre aide

    tchao

    Charly
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  19. #19
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    En faite j'ai modifié mon code pour pouvoir mettre une fonction de tri a l'intérieur.

    Et la fonction écriture ne réécrie que les chaines du 2 eme fichier.
    Je ne comprend pas ce qui cloche.

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    /********** Déclaration des prototypes **********/
     
    int nb_lignes(FILE *,int ,char *);
    char ** lecture_fichier(FILE *,char *,int ,int);
    void ecriture_fichier(FILE *,char **, int);
    void tri(char **,int);
     
    /********** Fonction main **********/ 
     
    int main(void)
    {
     
    char ligne[10];
    FILE *f1,*f2,*f3;
    char **matrice_lecture;
    int i,nb,temp_nb=0,taille=26;
     
     
    f1=fopen("f1.txt","r");
         if(f1==0)
         {
                   perror("Erreur dans l'ouverture du fichier f1.txt");
                   exit(0);
         }
     
    printf("Voici les chaines du fichier f1 qui vont etre recopiees dans le fichier f3 :\n\n");
     
    nb=nb_lignes(f1,taille,ligne);
    temp_nb=temp_nb+nb;
    matrice_lecture=lecture_fichier(f1,ligne,taille,nb);
    fclose(f1);
     
     
    f2=fopen("f2.txt","r");
         if(f2==0)
         {
                  perror("Erreur dans l'ouverture du fichier f2.txt");
                  exit(0);
         }
     
    printf("Voici les chaines du fichier f2 qui vont etre recopiees dans le fichier f3 :\n\n");
     
    nb=nb_lignes(f2,taille,ligne);
    temp_nb=temp_nb+nb;
    matrice_lecture=lecture_fichier(f2,ligne,taille,nb);
    fclose(f2);
     
     
     
    f3=fopen("f3.txt","a");
    ecriture_fichier(f3,matrice_lecture,temp_nb);
    fclose(f3);
     
    free(ligne);
     
    for (i=0;i<temp_nb;i++) 
    {
    		free(matrice_lecture[i]);
    }
     
    free(matrice_lecture);
     
    printf("\n");
    system("pause");
     
    }
     
    /********** Fonction qui compte le nombres de lignes de caractères des fichiers f1 et f2 **********/
     
    int nb_lignes (FILE *f,int taille, char *tab)
    {
    int nb=0;
     
     
     
      while ( fgets(tab,taille, f) != NULL )
          { 
              nb++ ;
          }
     
    rewind(f);
    return (nb);
     
    }
     
    /********** Fonction lecture qui lie les chaînes de caractères des fichiers f1 et f2 **********/
     
    char ** lecture_fichier(FILE *f,char *t,int taille,int nb)
    {
     
    char **p=NULL;
    int i, j;
    static x=0;
     
    p=malloc(sizeof(*p)*(x+nb));
     
    	if ( !p ) {
    		fprintf(stderr,"probleme d'allocation memoire\n");
    		fflush(stderr);
    		exit(0);
    	}
     
    i=x;
     
    	for (i=0;i<(x+nb);i++) {
    		p[i]=malloc(taille);
    		if ( !p[i] ) {
    			fprintf(stderr,"probleme d'allocation memoire\n");
    			fflush(stderr);
    			exit(0);
    		}
    	}
     
    i=x;
     
    	while ( (i <(x+nb)) && (fgets(p[i],taille,f) != NULL) ) {
     
    		if ( p[i][strlen(p[i])-1] == '\n' ) {
    			p[i][strlen(p[i])-1] = '\0';
    		}
     
            printf("%s\n",p[i]);
    		printf("\n");
    		i++;
    	}
     
    	if ( i != (x+nb) ) {
    		printf("le nombre de lignes lues ne correspond pas à celui donné\n");
    	}
     
    x=x+nb;	
    return(p);
     
    }
     
    /********** Fonction ecriture qui recopie les chaînes de caracères des fichiers f1 et f2 dans le fichier f3 **********/
     
    void ecriture_fichier(FILE *f, char **p, int temp_nb) 
    {
    	int i;
     
     
    	for (i=0;i<temp_nb;i++) {
    		fprintf(f,"%s\n",p[i]);
    	}
     
    }
     
    /********** Fonction qui trie les lignes de caractères par nom **********/
     
    void tri(char **p,int temp_nb)
    {
         int i,j;
         char* temp;
         for(i=0;i<temp_nb;i++)
         {     
     
               for(j=i+1;j<temp_nb;j++)
               {
                       if(strcmp(p[i],p[j])>0) 
                       {
     
                             temp=p[j];
                             p[j]=p[i];
                             p[i]=temp;
     
                       }   
     
               }
     
         }
     
    }
    merci d'avance
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

  20. #20
    Membre régulier Avatar de charlix
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2006
    Messages
    285
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2006
    Messages : 285
    Points : 107
    Points
    107
    Par défaut
    Après encore beaucoup de réfléxion, je ne vois toujours pas comment faire pour que les chaines de caracteres du fichier f1 reste dans le tableau de chaines de caracteres matrice_lecture. Quand j'execute le programme le malloc met bien en place au bon endroit chaque chaine de caracteres dans matrice_lecture mais quand je lui dit d'ecrire dans f3( il ya le bon nombre de chaines de caractere ) mais il n'a pas garder les chaines du fichier f1 mais seulement celles du fichier f2.

    avec quelques modification de mon code d'avant ca donne :

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
    /********** Déclaration des prototypes **********/
     
    int nb_lignes(FILE *,int,char*);
    char ** lecture_fichier(FILE *,int ,int);
    void ecriture_fichier(FILE *,char **, int);
    void tri(char **,int);
    //char * fgets(char *, int, FILE *);                
     
    /********** Fonction main **********/ 
     
    int main(void)
    {
     
    char ligne[1];
    FILE *f1,*f2,*f3;
    char **matrice_lecture;
    int i,nb,temp_nb=0,taille=26;
     
     
    f1=fopen("f1.txt","r");
         if(f1==0)
         {
                   perror("Erreur dans l'ouverture du fichier f1.txt");
                   exit(0);
         }
     
    printf("Voici les chaines du fichier f1 qui vont etre recopiees dans le fichier f3 :\n\n");
     
    nb=nb_lignes(f1,taille,ligne);
    temp_nb=temp_nb+nb;
    matrice_lecture=lecture_fichier(f1,taille,nb);
    fclose(f1);
     
     
     
    f2=fopen("f2.txt","r");
         if(f2==0)
         {
                  perror("Erreur dans l'ouverture du fichier f2.txt");
                  exit(0);
         }
     
    printf("Voici les chaines du fichier f2 qui vont etre recopiees dans le fichier f3 :\n\n");
     
    nb=nb_lignes(f2,taille,ligne);
    temp_nb=temp_nb+nb;
    matrice_lecture=lecture_fichier(f2,taille,nb);
    fclose(f2);
     
    f3=fopen("f3.txt","w");
    ecriture_fichier(f3,matrice_lecture,temp_nb);
    fclose(f3);
     
     
    for (i=0;i<temp_nb;i++) 
    {
    		free(matrice_lecture[i]);
    }
    free(matrice_lecture);
     
     
    printf("\n");
    system("pause");
    return 0;
    }
     
    /********** Fonction qui compte le nombres de lignes de caractères des fichiers f1 et f2 **********/
     
     
    int nb_lignes (FILE *f,int taille, char *tab)
    {
    int nb=0;
     
      while ( fgets(tab,taille, f) != NULL )
          { 
              nb++ ;
          }
     
      rewind(f);
      return (nb);
     
    }
     
    /********** Fonction lecture qui lie les chaînes de caractères des fichiers f1 et f2 **********/
     
    char ** lecture_fichier(FILE *f,int taille,int nb)
    {
     
    static char **p=(char**) NULL;
    int i;
    static int x=0;
     
    p=malloc((x+nb)*sizeof(*p));
     
    	if (!p)
        {
    		fprintf(stderr,"probleme d'allocation memoire\n");
    		fflush(stderr);
    		exit(0);
    	}
     
    i=x;
     
    	for (i=0;i<(x+nb);i++)
        {
    		p[i]=malloc(taille);
     
    		if ( !p[i] )
            {
    			fprintf(stderr,"probleme d'allocation memoire\n");
    			fflush(stderr);
    			exit(0);
    		}
    	}
     
    i=x;
     
    	while ( (i <(x+nb)) && (fgets(p[i],taille,f) != (char *) NULL) ) 
        {
     
    		if ( p[i][strlen(p[i])-1] == '\n' ) 
            {
    			p[i][strlen(p[i])-1] = '\0';
    		}
     
            printf("%s",p[i]);
    		printf("\n");
    		i++;
    	}
     
    	if ( i != (x+nb) ) printf("le nombre de lignes lues ne correspond pas à celui donné\n");
     
     
    x=x+nb;	
    return(p);
     
    }
     
    /********** Fonction ecriture qui recopie les chaînes de caracères des fichiers f1 et f2 dans le fichier f3 **********/
     
    void ecriture_fichier(FILE *f, char **p, int temp_nb) 
    {
    	int i;
     
    	for (i=0;i<temp_nb;i++) fprintf(f,"%s\n",p[i]);
     
    }
     
    /********** Fonction qui trie les lignes de caractères par nom **********/
     
    void tri(char **p,int temp_nb)
    {
         int i,j;
         char* temp;
         for(i=0;i<temp_nb;i++)
         {     
               for(j=i+1;j<temp_nb;j++)
               {
                       if(strcmp(p[i],p[j])>0) 
                       {
                             temp=p[j];
                             p[j]=p[i];
                             p[i]=temp;
                       }   
               }
         }
    }
    Est ce qu'il y a un probleme de position de pointeur dans matrice_lecture ? ou est ce un probleme avec le malloc ? Car je pense que la fonction ecriture fichier est correcte, donc le probleme doit provenir des lignes :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    matrice_lecture=lecture_fichier(f1,taille,nb);
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    matrice_lecture=lecture_fichier(f2,taille,nb);
    Lorsque je divisais le travail avec deux matrices lectures differentes , tout fonctionnait bien.

    merci d'avance
    Il faut toujours avoir l'air d'être con si on veut pouvoir paraitre intelligent de temps en temps.

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Lecture et Ecriture dans un fichier Excel
    Par qiqi1111 dans le forum C++
    Réponses: 2
    Dernier message: 18/12/2008, 19h10
  2. lecture et ecriture dans un fichier PDF
    Par kha_yassine dans le forum Documents
    Réponses: 1
    Dernier message: 05/07/2007, 19h36
  3. Réponses: 4
    Dernier message: 19/02/2007, 18h58
  4. Réponses: 2
    Dernier message: 26/09/2003, 14h51

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