Problème avec fwrite sous windows

**cerede2000** · 05/10/2008, 11h00

Bonjour,

Je travaille avec un fichier binaire sous windows, au moment d'écrire dans le fichier aucun soucis ça se passe très bien, mais j'ai des choses en plus dans le fichier qui se rajoute a la fin.
En faite j'ai l'impression que ce sont des bout de PATH

Voici le code d'écriture:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void Sauvegarde(void) {
	FILE *fd = fopen("carnet.bin", "ab");
	if(fd) {
		int i = 0;
		for(i = 0; i < nbpers; i++) {
			if(fwrite(carnet[i], sizeof(fiche), 1, fd))
				printf("Bien sauvegardé\n");
		}
		fclose(fd);
	}
}

carnet est un tableau de pointeur sur une structure et nbpers est le nombre d'éléments dans le tableau.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
typedef struct {
	char nom[50];
	char prenom[50];
	char tel[16];
	unsigned char age;
} fiche;
 
fiche *carnet[50];

je met la fonction de recuperation aussi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void Restaurer(void) {
	FILE *fd = fopen("carnet.bin", "rb");
	if(fd) {
		nbpers = 0;
		while(!feof(fd)) {
			carnet[nbpers] = malloc(sizeof(fiche));
			fread(carnet[nbpers], sizeof(fiche), 1, fd);
			nbpers++;
		}
		fclose(fd);
	}
}

Si quelqu'un sait d'où ça peut venir.

Merci

**Emmanuel Delahaye** · 05/10/2008, 13h11

Envoyé par cerede2000

Je travaille avec un fichier binaire sous windows, au moment d'écrire dans le fichier aucun soucis ça se passe très bien, mais j'ai des choses en plus dans le fichier qui se rajoute a la fin.

Ton code utilise des globales (horrible !). On ne sait pas qui manipule quoi, qui alloue, qui libère, comment sont créées les données à sauvegarder. Bref, on ne peut pas corriger ton code. Il est incomplet.

Es-tu certain du choix du mode "ab" pour écrire ? Ça signifie que tu ajoutes au fichier existant. C'est ce que tu veux ? Pour une sauvegarde, j'aurais mis "wb"...
feof() ne fait pas ce que tu crois. Il faut tester la valeur retournée par la fonction de lecture. C'est la règle.

Je verrais une approche plus orientée objet.

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
 
/* http://delahaye.emmanuel.free.fr/clib/ */
#include "ed/inc/io.h"
 
#include <stdio.h>
#include <stdlib.h>
 
#define FNAME "carnet.bin"
typedef struct
{
   char nom[50];
   char prenom[50];
   char tel[16];
   unsigned char age;
}
fiche;
 
typedef struct
{
   fiche *carnet[50];
   int nbpers;
}
fichier;
 
void Saisir (fichier * p_fic)
{
   while (p_fic->nbpers < 50)
   {
      fiche *f = malloc (sizeof *f);
      if (f != NULL)
      {
         printf ("Nom    : ");
         get_s (f->nom, sizeof f->nom);
         if (*f->nom == 0)
         {
            break;
         }
         else
         {
            printf ("Prenom : ");
            get_s (f->prenom, sizeof f->prenom);
 
            printf ("Tel    : ");
            get_s (f->tel, sizeof f->tel);
 
            printf ("Age    : ");
            {
               long num;
               get_l (&num);
               f->age = num;
            }
            p_fic->carnet[p_fic->nbpers] = f;
            p_fic->nbpers++;
         }
      }
      else
      {
         break;
      }
   }
}
 
void Afficher (fichier const *p_fic)
{
   if (p_fic->nbpers > 0)
   {
      int i;
      for (i = 0; i < p_fic->nbpers; i++)
      {
         fiche const *f = p_fic->carnet[i];
         printf ("%-16s%-16s%3d%-17s\n", f->nom, f->prenom, f->age, f->tel);
      }
   }
   else
   {
      printf ("<vide>\n");
   }
   printf ("\n");
}
 
void Sauvegarder (fichier const *p_fic)
{
   FILE *fd = fopen (FNAME, "wb");
   if (fd)
   {
      int i;
      for (i = 0; i < p_fic->nbpers; i++)
      {
         fiche *f = p_fic->carnet[i];
         if (fwrite (f, sizeof *f, 1, fd) > 0)
         {
            printf ("Bien sauvegardé\n");
         }
      }
      fclose (fd);
   }
}
 
void Effacer (fichier * p_fic)
{
   int i;
 
   for (i = 0; i < p_fic->nbpers; i++)
   {
      free (p_fic->carnet[i]), p_fic->carnet[i] = NULL;
   }
   p_fic->nbpers = 0;
}
 
void Restaurer (fichier * p_fic)
{
   FILE *fd = fopen (FNAME, "rb");
   if (fd)
   {
      int end;
      p_fic->nbpers = 0;
 
      do
      {
         fiche *p = malloc (sizeof *p);
         end = p == NULL;
         if (!end)
         {
            end = fread (p, sizeof *p, 1, fd) < 1;
            if (!end)
            {
               p_fic->carnet[p_fic->nbpers] = p;
               p_fic->nbpers++;
            }
            else
            {
               free (p), p = NULL;
            }
         }
      }
      while (!end && p_fic->nbpers <= 50);
      fclose (fd);
   }
}
 
int main (void)
{
   fichier fic;
 
   Restaurer (&fic);
   Afficher (&fic);
 
   Saisir (&fic);
   Afficher (&fic);
 
   Sauvegarder (&fic);
   Effacer (&fic);
   Afficher (&fic);
 
   Restaurer (&fic);
   Afficher (&fic);
 
   return 0;
}

**cerede2000** · 05/10/2008, 13h17

feof retourne bien vrai quand la fin du fichier est atteins non?
En quoi l'utilisation de variable globales est il gênant? (Pour le moment elle sont la pour tester les fonctions)

Et mon problème venait de ma fonction Sauvegarde.

Ici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for(i = 0; i < nbpers; i++) {
			if(fwrite(carnet[i], sizeof(fiche), 1, fd))
				printf("Bien sauvegarde\n");
		}

Comment puis-je écrire tout mon tableau d'un coup? Sans le parcourir de cette manière?

**souviron34** · 05/10/2008, 14h24

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
			if(fwrite(carnet, sizeof(fiche), nbpers, fd))

**Emmanuel Delahaye** · 05/10/2008, 14h38

Envoyé par cerede2000

feof retourne bien vrai quand la fin du fichier est atteins non?

Non, pas du tout. J'ai déjà indiqué comment faire.

http://emmanuel-delahaye.developpez....s.htm#fichiers

En quoi l'utilisation de variable globales est il gênant?

Déjà dit. On ne sait pas qui fait quoi.

(Pour le moment elle sont la pour tester les fonctions)

Mauvais raisonnement. Il faut écrire du code correct dès la première ligne. L'expérience montre qu'une fois qu'un code tourne, on ne le modifie plus... Tu risques donc de te retrouver au final avec du code mal écrit... (problème récurrent, archi débattu... merci de ne pas insister... Les globales, çaÿ mal. Point.)

Et mon problème venait de ma fonction Sauvegarde.

Ici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for(i = 0; i < nbpers; i++) {
			if(fwrite(carnet[i], sizeof(fiche), 1, fd))
				printf("Bien sauvegarde\n");
		}

Comment puis-je écrire tout mon tableau d'un coup? Sans le parcourir de cette manière?

C'est pas possible, car il n'est pas linéaire.

Mais peu importe le moyen, c'est le résultat qui compte.

**Emmanuel Delahaye** · 05/10/2008, 14h40

Envoyé par souviron34

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
			if(fwrite(carnet, sizeof(fiche), nbpers, fd))

Oh, la belle collection de pointeurs... Bien lire l'énoncé. (j'ai failli me faire piéger aussi si ça peut te rassurer !)

**cerede2000** · 05/10/2008, 14h50

Le soucis c'est que je doit ensuite faire évoluer mon programme vers une version qui se passera de la limite de 50 fiches et également de la limite des champs de la fiche (Avec quand même un buffer de réception limité mais bon).

Je doit donc plutôt utiliser un système de pile non?
Et puis est-ce faisable de rester sur le stockage en binaire pour faire sauter la tailles des champs en optimisant la taille occupé dans le fichier?

**Emmanuel Delahaye** · 05/10/2008, 14h57

Envoyé par cerede2000

Le soucis c'est que je doit ensuite faire évoluer mon programme vers une version qui se passera de la limite de 50 fiches et également de la limite des champs de la fiche (Avec quand même un buffer de réception limité mais bon).

Je doit donc plutôt utiliser un système de pile non?

Je ne vois pas le rapport...

Et puis est-ce faisable de rester sur le stockage en binaire pour faire sauter la tailles des champs en optimisant la taille occupé dans le fichier?

Si tu dois faire une application réelle :

1 - oublie le format binaire
2 - définit un format texte 'CSV fait l'affaire : "nom;prenom;age;telephone\n"
3 - passe tout en dynamique (tableau de pointeurs souple ou liste chainée, par exemple, tout dépend des traitements à appliquer : liste : création, suppression, modifications, insertion. Tableau : tris, recherches ...).

Ou alors apprends à utiliser SQL ! (SQLite, par exemple suffit pour des petites applications).

**cerede2000** · 05/10/2008, 15h05

Eu non je n'ai pas à utiliser une base de données

Par contre c'est quoi tableau de pointeurs souple?
Et pour faire sauter la limite des 50 fiches qu'est il mieux d'utiliser?

Et d'ou sort le get_s?

**Emmanuel Delahaye** · 05/10/2008, 15h24

Envoyé par cerede2000

Eu non je n'ai pas à utiliser une base de données

Pourquoi ?

Par contre c'est quoi tableau de pointeurs souple?

Tu définis un pointeur de base ;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

T **pp;

ensuite tu alloues un bloc de N pointeurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pp = malloc (N * sizeof *pp);

que tu peux ensuite agrandir avec realloc() en cas de besoins.

http://emmanuel-delahaye.developpez....tes.htm#malloc
http://emmanuel-delahaye.developpez....es.htm#realloc

Et pour faire sauter la limite des 50 fiches qu'est il mieux d'utiliser?

Déjà répondu. Ca dépend de l'usage :

Envoyé par -ed-

Liste : création, suppression, modifications, insertion.
Tableau : tris, recherches

Et d'ou sort le get_s?

De ma bibliothèque perso. J'ai donné les indications en haut du code ...

**cerede2000** · 05/10/2008, 15h42

Pas de BDD car je doit simplement travaillé avec des fonctions standards et utiliser un fichier texte simple ou binaire mais bon c'est tout.

Je n'apprécie pas vraiment realloc, je vais plutôt partir sur de la liste chaîné.

En gros je doit proposer:
Liste : création, suppression, recherche

Que me conseil tu?

**Emmanuel Delahaye** · 05/10/2008, 16h14

Envoyé par cerede2000

Pas de BDD car je doit simplement travaillé avec des fonctions standards et utiliser un fichier texte simple ou binaire mais bon c'est tout.

C'est donc un projet scolaire. Il est bon de le préciser dès le début...

Je n'apprécie pas vraiment realloc,

Peu importe. C'est une fonction utile qu'il faut savoir utiliser.

je vais plutôt partir sur de la liste chaîné.

En gros je doit proposer:
Liste : création, suppression, recherche

Que me conseil tu?

Tu fais une liste (OK pour création, suppression). Pour la recherche, ça dépend de la taille Jusqu'à 100 fiches environ, une recherche linéaire suffit. La liste suffit donc.

Au-delà, créer un tableau dynamique à partir de la liste, le trier (qsort()) et faire une cherche dichothomique (bsearch()).

**cerede2000** · 05/10/2008, 16h30

Une liste simplement chaîné suffit non?

Pour ce qui est de realloc je sait l'utiliser mais bon

Sinon pour faire sauter la limite des champs je pensais bien faire comme ce que tu as dit plus haut:

2 - définit un format texte 'CSV fait l'affaire : "nom;prenom;age;telephone\n"

Donc utilisation de la fonction strtok pour séparer les champs a l'import?

**Emmanuel Delahaye** · 05/10/2008, 16h34

Envoyé par cerede2000

Une liste simplement chaîné suffit non?

Oui.

Sinon pour faire sauter la limite des champs je pensais bien faire comme ce que tu as dit plus haut:

Donc utilisation de la fonction strtok pour séparer les champs a l'import?

Par exemple...

**cerede2000** · 05/10/2008, 16h35

Par exemple?
Pourquoi il existe quoi d'autre?

**Emmanuel Delahaye** · 05/10/2008, 16h38

Envoyé par cerede2000

Par exemple?
Pourquoi il existe quoi d'autre?

strtok() souffre de certains défauts qui peuvent être génants ou non (statique interne, destruction de la source...). La fonction POSIX.1 strtok_r() résout le premier problème.

**cerede2000** · 05/10/2008, 16h41

Ok je n'avais jamais remarqué la fonction strtok_r dans le manuel

Merci bien pour tous ces conseils

**Emmanuel Delahaye** · 05/10/2008, 16h55

Envoyé par cerede2000

Ok je n'avais jamais remarqué la fonction strtok_r dans le manuel

Je ne sais pas de quel manuel tu parles, mais comme déjà précisé, strtok_r() n'est pas standard. Par contre, comme elle est POSIX.1, elle est très portable.