Fwrite() et fread() : les données ne correspondent pas

Bonjour j'ai fait deux fonction une fonction save et load permettant de sauvegarder et charger ma structure

Sauvegarde :

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
 
void saveZone(zone* z)
{
FILE* fd  =NULL;
int size = 7;
 
 
if(nbZone >9)
size++;
 
if(nbZone>99)
size++;
 
char nullvalue = -1;
short nullvalueshort = -1;
char buff[size];
char path[] = "zone/%d";
 sprintf(buff, path, nbZone-1);
fd = fopen(buff,"ab+");
 
  if(fd == NULL) {
    perror("Erreur ouverture fichier ");
    exit(EXIT_FAILURE);
  }
 
  if(!fwrite( &z->sizex,sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de sizex ");
    exit(EXIT_FAILURE);
  }
   if(!fwrite( &z->sizey, sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de sizey ");
    exit(EXIT_FAILURE);
  }
 
 
 
 if(!fwrite( &z->foodSpawnfreq,sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de foodSpawnfreq ");
    exit(EXIT_FAILURE);
  }
   if(!fwrite( &z->foodUnit,sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de foodUnit ");
    exit(EXIT_FAILURE);
  }
   if(!fwrite( &z->sourceFood,sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de sourceFood ");
    exit(EXIT_FAILURE);
  }
int i=0;
for(i=0;i< (z->sizex * z->sizey);i++)
{
 
 
 
	Case* c = z->cases[i];
 
 
 
 
	if(!fwrite( &c->obstacle, sizeof(char),1,fd)) {
	    perror("Erreur lors de l'ecriture de obstacle ");
	    exit(EXIT_FAILURE);
	  }
 
 
	 if(c->bibit != NULL)
	 {
 
		bibite* b = c->bibit;
		if(fwrite( &b->type,sizeof(char),1,fd) == -1) {
		    perror("Erreur lors de l'ecriture de type ");
		    exit(EXIT_FAILURE);
		  }
 
	  }
	 else if(fwrite( &nullvalue,sizeof(char),1,fd) == -1) {
		    perror("Erreur lors de l'ecriture de l'entier 3");
		    exit(EXIT_FAILURE);
	 }
 
 
  if(c->fourmi != NULL)
	 {
	   fourmis* f = c->fourmi;
		if(fwrite( &f->type,sizeof(char),1,fd) == -1) {
		    perror("Erreur lors de l'ecriture de type ");
		    exit(EXIT_FAILURE);
		  }
 
 
	  }
	 else if(fwrite( &nullvalue,sizeof(short),1,fd) == -1) {
		    perror("Erreur lors de l'ecriture de l'entier 2");
		    exit(EXIT_FAILURE);
	 }
 
 
	 if(c->fourmilier != NULL)
	 {
	   short i;
	   fourmiliere* f = c->fourmilier;
 
		if(fwrite( &f->nbTypeFourmis,sizeof(short),1,fd) == -1) {
		    perror("Erreur lors de l'ecriture de type ");
		    exit(EXIT_FAILURE);
		  }
          int j = 0;
		  for(j=0;j<f->nbTypeFourmis;j++)
		  {
		   TypeFourmi *tf = f->typeFourmis[j];
 
               if(fwrite( &f->probaSpawn[j], sizeof(float),1,fd) == -1) {
                perror("Erreur lors de l'ecriture de a probabilité du type ");
                exit(EXIT_FAILURE);
              }
 
		  }
	  }
	 else if(fwrite( &nullvalueshort,sizeof(short),1,fd) == -1) {
		    perror("Erreur lors de l'ecriture de l'entier 1");
		    exit(EXIT_FAILURE);
	 }
 
 
 
 
}
 
  fclose(fd);

Chargement :

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
 
 
 
zone* loadzone(char* path)
{
FILE* fd = NULL;
zone* z = malloc(sizeof(zone));
 
fd = fopen(path, "r");
 
  if(fd == -1) {
    perror("Erreur ouverture fichier ");
    exit(EXIT_FAILURE);
  }
 
  if(!fread( &z->sizex ,sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de sizex ");
    exit(EXIT_FAILURE);
  }
   if(!fread( &z->sizey,sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de sizey ");
    exit(EXIT_FAILURE);
  }
 if(!fread( &z->foodSpawnfreq, sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de foodSpawnfreq ");
    exit(EXIT_FAILURE);
  }
   if(!fread( &z->foodUnit, sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de foodUnit ");
    exit(EXIT_FAILURE);
  }
   if(!fread( &z->sourceFood, sizeof(short),1,fd)) {
    perror("Erreur lors de l'ecriture de sourceFood ");
    exit(EXIT_FAILURE);
  }
 
  z->cases = malloc(sizeof(Case)*z->sizex * z->sizey);
printf("%d",z->sizex * z->sizey);
 
int i=0;
for(i=0;i< (z->sizex * z->sizey);i++)
{
  char typebibite;
  char typeFourmi;
  short nbTypeFourmis;
 
 
 
 
 
 Case*   c = &z->cases[i];
 
 
	if(fread( &c->obstacle, sizeof(char),1,fd) == -1) {
	    perror("Erreur lors de l'ecriture de obstacle ");
	    exit(EXIT_FAILURE);
	  }
 
	  printf("%d::%d\n",c->obstacle,i);
 
	if(fread( &typebibite, sizeof(char),1,fd) == -1) {
	    perror("Erreur lors de l'ecriture du type ");
	    exit(EXIT_FAILURE);
	  }
 
	  if(fread( &typeFourmi,sizeof(char),1,fd) == -1) {
		    perror("Erreur lors de l'ecriture de type ");
 
		    exit(EXIT_FAILURE);
		  }
 
    if(fread( &nbTypeFourmis, sizeof(short),1,fd) == -1) {
		    perror("Erreur lors de l'ecriture de type ");
		    exit(EXIT_FAILURE);
        }
 
 
if(typebibite != -1)
{
		c->bibit =malloc(sizeof(bibite));
		bibite* b = &c->bibit;
        b->type = typebibite;
 
}
 
 
 
 
 
if(typeFourmi != -1)
{
        c->fourmi = malloc(sizeof(fourmis));
	   fourmis* f = c->fourmi;
        f->type = typeFourmi;
}
 
 
 
	 if(nbTypeFourmis != -1)
	 {
	 if(typesfourmis == NULL)
	 typesfourmis = loadTypeFourmis();
 
 
	   c->fourmilier = creerFourmilier(nbTypeFourmis,typesfourmis);
	   fourmiliere* f = c->fourmilier;
        f->nbTypeFourmis = nbTypeFourmis;
 
        int j=0;
		  for(j=0;j<f->nbTypeFourmis;j++)
		  {
		   TypeFourmi *tf = f->typeFourmis[j];
 
 
               if(fread( &f->probaSpawn[j], sizeof(float),1,fd) == -1) {
                perror("Erreur lors de l'ecriture du type de fourmis ");
                exit(EXIT_FAILURE);
              }
 
		  }
	  }
 
}
 
  fclose(fd);
  getchar();
 
 
}

Le contexte

Chaque case doit être marqué dans un fichier en binaire les cases dans mon cas ont toujours leur fourmi NULL et leur bibite NULL , donc d'aprés ma fonction de sauvegarde on marque -1 dans le fichier ( j'ai tester avec un point d’arrêt)
Seulement quand je charge les données avec ma fonction load pendant le chargement des cases j'obtiens pas toujours des -1.

Je débute, et je suis dans incompréhension depuis hier. Merci d'avance

Si tu veux utiliser fread(), tu dois ouvrir un fichier en mode "rb" et non "r".
De plus, dans ton save, pourquoi ouvrir le fichier en "ab+" si tu ne fais que des écritures? "ab" (voire même "wb" si c'est un overwrite complet que tu veux) suffirait...

D'accord , j'ai suivie tes conseils. Aucun changement, j'ai l'impression que tout est decalé , la variable obstacle a comme valeur ue typefourmi devrai avoir.

Je ne comprend pas pourtant j'ecris bien dans le même ordre que je lis

Bonjour,
Les données écrites doivent avoir exactement la même taille en écriture et en lecture.
Si un champ est "absent", il faut comme tu l'as fait enregistrer un token te permettant de détecter ce cas en lecture.
Ce token doit :
* être totalement distinguable de la valeur écrite, il vaut -1 dans ton cas.
* avoir une taille bien identifiée
* la lecture doit rester compatible donc doit lire exactement la longueur du token, ni plus ni moins si on est dans ce cas.
Hors dans le code !
* pour bibit, tout fait un octet (data écrite, token ecrit, data lue<=>token lu)
* pour fourmi, cela n'est pas le cas! (data=1octet, token=2octets,...)
Je suppose que les 2 variables nullvalue et numvalueshort valent -1.

En effet nullvalue est bien egal a -1 et c'est bien mon token.Par contre j'écris avec un sizeof(char) le soucis viens peut être de la ?

Et oui je lis de la même façon que j'écris (même taille)

Ligne 92, il y a :

Code:

else if(fwrite( &nullvalue,sizeof(short),1,fd) == -1) {

Le sizeof est ok, -1 étant rempli de bits à 1, il peut être écrit en sizeof(char),sizeof(short) ou sizeof(int) et symétriquement lu comme un signed char,short ou int.

Du coup pour le moment aucune solution a mon probleme.