Problémes avec fichiers, arboresence et structures

Version imprimable

09/05/2008, 00h47
waloo92i

Problémes avec fichiers, arboresence et structures

Bonsoir je suis étudiant en L2 maths informatique et j'ai du mal avec un projet
je ne sais pas comment procéder pour faire sa :

Il s'agit dans un premier temps de créer un fichier à partir du clavier ou chaque enregistrement est formé d'un nom et d'un solde, puis charger ce fichier en mémoire centrale pour le trier par ordre alphabétique avant d'écraser ce fichier avec le fichier trié.
Puis dans un deuxiéme temps il faut prévoir la modification du solde directement sur le fichier trié.

si vous pouviez m'éclairer ou me guider un petit peu ou me monter un exmple.
merci d'avance.
09/05/2008, 02h22
ToTo13
Bonsoir,

pour ce qui est de remplir à la main le fichier, tu n'as pas besoin de nous.
Pour le reste, tu as presque écrit toi même la réponse :)
Toutes tes informations vont par deux :
1. un nom
2. un solde
Donc il te faut une structure avec un champ pour le nom et un champ pour le solde (je te laisse deviner le type de chaque champ).

Pour ce qui est de trier des noms, tu as la fonction strcmp, voire la fonction qsort qui tri.

Pour ce qui est de modifier le solde dans le fichier trié, le plus simple est de le charger, de le modifier, puis de l'écrire.
09/05/2008, 14h30
waloo92i

oui merci de votre réponse je vois un peu prés ce que je dois faire en ce qui concerne la structure le probléme c'est pour écrire trié et écrasé le fichier je n'ai encore jamais fait sa donc je ne sait vraiment pas comment m'y prendre.

voila ce que j'arrive a faire pour le moment mais je ne sais pas si c'est bon si quelqu'un pourait me coriger ou me compléter:roll:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Tree {
       char name[32];
       char number[32];
       struct tree * left;
       struct tree * right;
       }* root;
 
       void addItem(struct Tree * root, struct Tree * Parain, int bDir, struct Tree * Item)
       {
            if (root)
            {
                     if(strcmp(root->name, Item->name)<0)
                     {
                           addItem(root->left, root, 0, Item);
                     }
                     else
                       if (strcmp(root->name, Item->name)>0)
                       {
                                              addItem(root->right, root, 1, Item);
                       }
                       else
                         if (strcmp(root->number, Item->number)<0)
                         {
                                                  addItem(root->left, root, 0, Item);
                         }
                         else
                         {
                             addItem(root->right, root, 1, Item);
                         }
            }
            else
            { 
                if (bDir)
                    Parain->right=Item;
                    else
                    Parain->left=Item;
            }
        }
 
 
        int fCreerArbre (File *file)
        {
            char sBuf[128];
            struct Tree * Item;
 
            while (fgets(sBuf, 128, file))
            {
                  Item=(struct Tree*)malloc(sizeof(struct Tree));
                  sscanf(sBuf, "%s[31] %s[31]", Item->name, Item->number);
                  Item->left=NULL;
                  Item=right=NULL;
                  if (root)
                  addItem(root, root, 0, Item);
                  else
                  root=item;
                  }
            }
 
            int fparcoursArbre(FILE * file, struct Tree * root)
            {
                if(root)
                {
                        fparcoursrbre(file, root->left);
                        fprintf(file, "%s %s \r\n", root->name, root->number);
                        fparcoursArbre(file, root->right);
                }
            }
 
      int main (int nargs, char ** args)
      {
          char * sInputFile;
          char * sOutputFile;
          FILE * fInputFile;
          FILE * fOutputFile;
 
          sInputFile=(char *)malloc(strlen(args[1])*sizeof(char)+1);
          strcpy(sInputFile, args[1]);
          sInputFile [strlen(args[1])];
 
          sOutputFile=(char *)malloc(strlen(args[1])*sizeof(char)+1);
          strcpy(sOutputFile, args[1]);
          sOutputFile [strlen(args[1])];
 
          fInputFile=fopen(sInputFile, "r+");
          fOutputFile=fopen(sOutputFile, "w+");
 
          fCreerArbre(fInputFile);
          fParcoursArbre(fOutputFile, root);
 
          fclose(fInputFile);
          fclose(fOutputFile);
          return 0;
          }

09/05/2008, 19h14
souviron34

t'as essaye de compiler ??

Corrige d'abord toutes les erreurs....

voila ce que sa donne sans erreur mais par contre en ce qui concerne les warnings je n'ai aucune idées de comment m'en débarasser :bug:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Tree {
       char name[32];
       char number[32];
       struct tree * left;
       struct tree * right;
       }* root;
 
       void addItem(struct Tree *root, struct Tree *Parain, int bDir, struct Tree *Item)
       {
            if (root)
            {
                     if(strcmp(root->name, Item->name)<0)
                     {
                           addItem(root->left, root, 0, Item);
                     }
                     else
                       if (strcmp(root->name, Item->name)>0)
                       {
                           addItem(root->right, root, 1, Item);
                       }
                       else
                         if (strcmp(root->number, Item->number)<0)
                         {
                            addItem(root->left, root, 0, Item);
                         }
                         else
                         {
                             addItem(root->right, root, 1, Item);
                         }
            }
            else
            { 
                if (bDir)
                    Parain->right=Item;
                    else
                    Parain->left=Item;
            }
        }
 
 
        int fCreerArbre (FILE* file)
        {
            char sBuf[128];
            struct Tree * Item;
 
            while (fgets(sBuf, 128, file))
            {
                  Item=(struct Tree*)malloc(sizeof(struct Tree));
                  sscanf(sBuf, "%s[31] %s[31]", Item->name, Item->number);
                  Item->left=NULL;
                  Item->right=NULL;
                  if (root)
                  addItem(root, root, 0, Item);
                  else
                  root=Item;
                  }
            }
 
            int fparcoursArbre(FILE * file, struct Tree * root)
            {
                if(root)
                {
                        fparcoursArbre(file, root->left);
                        fprintf(file, "%s %s \r\n", root->name, root->number);
                        fparcoursArbre(file, root->right);
                }
            }
 
      int main (int nargs, char ** args)
      {
          char * sInputFile;
          char * sOutputFile;
          FILE * fInputFile;
          FILE * fOutputFile;
 
          sInputFile=(char *)malloc(strlen(args[1])*sizeof(char)+1);
          strcpy(sInputFile, args[1]);
          sInputFile [strlen(args[1])];
 
          sOutputFile=(char *)malloc(strlen(args[1])*sizeof(char)+1);
          strcpy(sOutputFile, args[1]);
          sOutputFile [strlen(args[1])];
 
          fInputFile=fopen(sInputFile, "r+");
          fOutputFile=fopen(sOutputFile, "w+");
 
          fCreerArbre(fInputFile);
          fparcoursArbre(fOutputFile, root);
 
          fclose(fInputFile);
          fclose(fOutputFile);
          return 0;
          }

10/05/2008, 08h56
Melem

- struct Tree et struct tree ne sont pas la même chose (le C est sensible à la casse)
- root est une variable globale (déjà les globales c'est le mal ...) alors que t'as aussi dans addItem un paramètre nommé root (tu vois, les globales c'est la mal !).
- On ne caste pas malloc en C. malloc retourne un void *, type compatible avec tous les autres types pointeurs.
- Tu utilises mal sscanf, c'est :

Code:

sscanf(sBuf, "%31s %31s", Item->name, Item->number);

- Il faut libérer la mémoire allouée par malloc (free()) lorsqu'on n'en a plus besoin.

Tout a fait c'est juste j'ai tout rectifier plus aucune erreur tout compile mais bon ce programme ne fé rien car je pense qu'il y'a des probléme de mémoire mes malloc sont défaillant je n'ai pas apris a les faire autrement comment je pourait faire en sorte qu'ils marche corectement?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Tree {
       char nom[32];
       char number[32];
       struct Tree* left;
       struct Tree* right;
       }*root;
 
       void addItem(struct Tree *Root, struct Tree *Parain, int bDir, struct Tree *Item)
       {
            if (Root)
            {
                     if(strcmp(Root->nom, Item->nom)<0)
                     {
                           addItem(Root->left, Root, 0, Item);
                     }
                     else
                       if (strcmp(Root->nom, Item->nom)>0)
                       {
                           addItem(Root->right, Root, 1, Item);
                       }
                       else
                         if (strcmp(Root->number, Item->number)<0)
                         {
                            addItem(Root->left, Root, 0, Item);
                         }
                         else
                         {
                             addItem(Root->right, Root, 1, Item);
                         }
            }
            else
            { 
                if (bDir)
                    Parain->right=Item;
                    else
                    Parain->left=Item;
            }
        }
 
 
        int fCreerArbre (FILE* file)
        {
            char sBuf[128];
            struct Tree * Item;
 
            while (fgets(sBuf, 128, file))
            {
                  Item=(struct Tree*)malloc(sizeof(struct Tree));
                  sscanf(sBuf, "%s31 %s31", Item->nom, Item->number);
                  Item->left=NULL;
                  Item->right=NULL;
                  if (root)
                  addItem(root, root, 0, Item);
                  else
                  root=Item;
                  }
            }
 
            int fparcoursArbre(FILE *file, struct Tree *Root)
            {
                if(Root)
                {
                        fparcoursArbre(file, Root->left);
                        fprintf(file, "%s %s \r\n", Root->nom, Root->number);
                        fparcoursArbre(file, Root->right);
                }
            }
 
      int main (int argc, char ** args)
      {
          char * sInputFile;
          char * sOutputFile;
          FILE * fInputFile;
          FILE * fOutputFile;
 
          sInputFile=malloc(strlen(args[1])*sizeof(char)+1);
          strcpy(sInputFile, args[1]);
          sInputFile [strlen(args[1])];
 
          sOutputFile=malloc(strlen(args[1])*sizeof(char)+1);
          strcpy(sOutputFile, args[1]);
          sOutputFile [strlen(args[1])];
 
          fInputFile=fopen(sInputFile, "r+");
          fOutputFile=fopen(sOutputFile, "w+");
 
          fCreerArbre(fInputFile);
          fparcoursArbre(fOutputFile, root);
          (free(malloc));
          fclose(fInputFile);
          fclose(fOutputFile);
          return 0;
          }

bon j'ai essayer de simplifier mon programme mais il y'a toujours un souci il ne s'execute pas comme il devrait le debuger m'affiche une violation d'accés (erreur de segmentation je ne sais pas d'ou elle vient) voila le programme :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct{ 
          char NOM_PERS[30] ; 
          float solde ;
          }personne ;
int main()
{
  FILE *P_FICHIER; /* pointeur sur FILE */
  typedef struct{ 
          char NOM_PERS[30] ; 
          float solde ;
          }personne ;
 
    int  C,NB_ENREG , i;
 
  char NOM_FICHIER[30], tab[C];
 
  personne p;
 
  /* Première partie : 
     Créer et remplir le fichier */
 
  printf("Entrez le nom du fichier à créer : ");
  scanf("%s",&NOM_FICHIER);
  P_FICHIER = fopen(NOM_FICHIER, "a+");  /* write */
  printf("Nombre d'enregistrements à créer : ");
  scanf("%d",&NB_ENREG);
  C = 0;
  while (C<NB_ENREG)
     { 
      printf("Entrez le nom de la personne : ");
      scanf("%s",p.NOM_PERS);
      fprintf(P_FICHIER, "%s ", p.NOM_PERS);
      printf("entrez un solde : ");
      scanf("%f",&p.solde);
      fprintf(P_FICHIER,"%f\n",p.solde);
      C++;
     }
  for(i=0 ; i< C ; i++){
          tab[i]==p.NOM_PERS[30] ;
          fprintf(P_FICHIER,"%s",tab[i]);
          }
 
  fclose(P_FICHIER);
    /* Deuxième partie : 
     Lire et afficher le contenu du fichier */
  P_FICHIER = fopen(NOM_FICHIER, "r");  /* read */
  C = 0;
  while (!feof(P_FICHIER))
     {
      fscanf(P_FICHIER, "%s", p.NOM_PERS);
       fscanf(P_FICHIER, "%f\n",p.solde);
C++;
     }
  for(i=0 ; i< C ; i++){
          fscanf(P_FICHIER,"%s",tab[i]);
          }
 
 
  fclose(P_FICHIER);
 
   return 0;
   }

12/05/2008, 10h24
ToTo13
Bonjour,

alors deux erreurs :
- Il est inutile de redéclarer la structure dans le main.
- Tu déclares un "tab[C]", alors que C est une variable non affectée. D'ailleurs, je ne sais pas qu'elles sont les options de compilation que tu utilises, mais chez moi ça génère une erreur à la compilation. Par défaut, le variable C=0 et donc tu fais une erreur de segmentation en appelant "tab[i]".

pour compléter ce que dit ToTo13 :
Code:

1 2 3 4 ... for(i=0 ; i< C ; i++){ tab[i]==p.NOM_PERS[30] ; fprintf(P_FICHIER,"%s",tab[i]); }...
- p.NOM_PERS[30] est hors du tableau
- la ligne tab[i]== ... ne fait rien. Sans doute tab[i]= ....
- tab[i] est un char, le format %s est incorrect. Idem pour
Code:

1 2 3 ... for(i=0 ; i< C ; i++){ fscanf(P_FICHIER,"%s",tab[i]); }...

Je ne comprends pas ce que tu cherches à faire avec:

Code:

1
2
3
4
5
for (i = 0 ; i < C; i++)
{
    tab[i]==p.NOM_PERS[30] ;
    fprintf(P_FICHIER,"%s",tab[i]);
}

Voici quelques corrections et commentaires sur ton code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define DEBUG
#define TAILLE_TAMPON 128
 
typedef struct
{
    char nom_pers[30] ;
    float solde ;
} personne;
 
void personne_afficher(personne *p_self)
{
    if (p_self != NULL)
    {
        printf("Personne: %s\nSolde: %.2f\n", p_self->nom_pers, p_self->solde);
    }
}
 
/* -tc- Elimine les caracteres non lus par scanf() */
void purge(void)
{
    int c;
 
    while ((c = fgetc(stdin)) != '\n' && c != EOF)
    {
    }
}
 
/* -tc- Elimine le caractere de fin ligne saisi par fgets() et purge les caracteres
   non lus en cas de saisie tronquee */
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)
            {
            }
        }
    }
}
 
int main(void)
{
    /* -tc- J'ai l'habitude de reserver les identificateurs en majuscules pour
       les constantes */
    FILE *p_fichier = NULL;
    int nb_enreg;
    int i;
    /* -tc- A moins de travailler volontairement avec les tableaux a longueur
       variable (C99), la taille d'un tableau doit être stpecifiee a l'aide
       d'une extression constante */
    char nom_fichier[30];
    personne p;
 
    /* Premiere partie :
       Creer et remplir le fichier */
 
    printf("Entrez le nom du fichier à créer : ");
    /* -tc- Il est recommande, pour etre portable, de forcer l'affichage de
       l'invite de saisie en appelant explicitement fflush() */
    fflush(stdout);
    /* -tc- Tu n'utilises pas scanf() correctement. Pour saisir un chaine, il
       faut au minimum indiquer la taille max de la saisie et purger les
       caracteres non lus apres usage. Par ailleurs, il est faut d'utiliser
       l'operateur & (adresse de) ici. */
    scanf("%29s", nom_fichier);
    purge();
 
    /* -tc- Il n'est pas recommande d'ouvrir un fichier en mode a+ */
    p_fichier = fopen(nom_fichier, "a+");
    /* -tc- Il est par contre fortement recommander de tester l'ouverture du
       fichier apres chaque appel de fopen() */
    if (p_fichier != NULL)
    {
        printf("Nombre d'enregistrements à créer : ");
        fflush(stdout);
        /* -tc- Pour une bonne utilisation de scanf(), il faudrait verifier que
           la valeur retournee par scanf() est bien egale a 1 */
        scanf("%d",&nb_enreg);
        purge();
 
        for (i = 0; i < nb_enreg; i++)
        {
            printf("Entrez le nom de la personne : ");
            fflush(stdout);
            scanf("%s",p.nom_pers);
            purge();
            fprintf(p_fichier, "%s ", p.nom_pers);
 
            printf("entrez un solde : ");
            fflush(stdout);
            /* -tc- Pour une bonne utilisation de scanf(), il faudrait verifier que
               la valeur retournee par scanf() est bien egale a 1 */
            scanf("%f", &p.solde);
            purge();
            fprintf(p_fichier, "%f\n", p.solde);
        }
 
        /* -tc- J'ai du mal a voir ce que tu cherches a faire, la. p.NOM_PERS[30]
        est un acces hors tableau...
        for (i = 0 ; i < C; i++)
        {
            tab[i]==p.NOM_PERS[30] ;
            fprintf(P_FICHIER,"%s",tab[i]);
        }
        */
 
        fclose(p_fichier), p_fichier = NULL;
 
        p_fichier = fopen(nom_fichier, "r");
        /* -tc- Toujours verifier que l'ouverture du fichier s'est bien passee */
        if (p_fichier != NULL)
        {
            char tampon[TAILLE_TAMPON] = "";
            nb_enreg = 0;
 
            while (fgets(tampon, TAILLE_TAMPON, p_fichier) != NULL)
            {
                fclean(tampon, p_fichier);
                sscanf(tampon, "%29s%f", p.nom_pers, &p.solde);
#ifdef DEBUG
                personne_afficher(&p);
#endif
                nb_enreg++;
            }
 
            fclose(p_fichier), p_fichier = NULL;
        }
        else
        {
            fprintf(stderr, "Erreur: impossible d'ouvrir le fichier en lecture\n");
        }
    }
    else
    {
        fprintf(stderr, "Erreur: impossible d'ouvrir le fichier en ecriture\n");
    }
 
    return 0;
}

Thierry