Problème de lecture d'un fichier !

Version imprimable

Chers amis,

Je fais appelle à votre aide pour la raison suivante. J'ai créé un programme assez simple qui réalise la création d'un tableau dynamique. Voici comment le programme se déroule. Après avoir lancé le programme l'utilisateur sélection le nombre de valeur que devra contenir son tableau. Ensuite il saisit les valeurs qu'il désire. Il accède enfin à un menu qui lui dit demande si il veut :

- 1 Editer la valeurs qu'il a tapé
- 2 Les écrire dans un fichier
- 3 Lire le fichier

Et mon problème se situe dans cette lecture. Autrement dit, tout fonctionne sauf la lecture. Attention mon programme à été réaliser sous Turbo C et la fonction principale, le prototype des fonctions (Mises dans un headerfiles) et les fonctions proprement sont séparés.

Voici le programme :

Le headerfiles de mes fonctions
------------------------------

Code:

1
2
3
4
5
6
7
8
9
10
11
#ifndef EXEMPLE.H
#define EXEMPLE.H
 
	int valeur () ;
	void saisie (float *tableau, int n) ;
	void edition (float *tableau, int n) ;
	int menu () ;
	void ecriture (float *tableau, int n) ;
	void lecture (float *tableau, int n) ;
 
#endif

La fonction Principale
--------------------

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
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include <stdlib.h>
 
#include <C:\EXEMPLE.H>
#include <C:\EXEMPLE.C>
 
void main (void)
{
 
	int n, choix ;
	float *tableau ;
 
	clrscr() ;
 
	n = valeur () ;
	tableau = (float*)malloc(n*sizeof(float)) ;
	saisie (tableau, n) ;
 
	do
	{
		choix = menu () ;
 
		switch (choix)
		{
 
			case 1 : edition (tableau, n) ;
					 break ;
 
			case 2 : ecriture (tableau, n) ;
					 break ;
 
			case 3 : lecture (tableau,n) ;
					 break ;
		}
	}while(choix !=0) ;
}

Les Fonctions
-------------

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
154
155
156
157
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include <stdlib.h>
#include <C:\COURS\TC\EXEMPLE\EXEMPLE.H>
 
/***********************/
/* Fonction nombre de valeur */
/*********/*************/
int valeur ()
{
	int a, x0, y0 ;
 
	printf ("Nombre de valeur à considérer > 0 : ") ;
	x0 = wherex () ;	y0 = wherey () ;
 
	do
	{
		gotoxy(x0,y0) ;
		clreol () ;
		scanf ("%d", &a) ;
 
	}while(a==0 || a<0) ;
 
	return (a) ;
}
 
/*****************/
/* Saisie des données */
/*****************/
void saisie (float *tableau, int n)
{
	int x1, y1, cpt ;
	float x ;
 
	clrscr () ;
 
	printf ("Saisie des données\n") ;
	printf ("ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n\n") ;
 
	cpt = 0 ;
 
	printf("\nValeur [%2d] : ", cpt) ;
	x1 = wherex() ;		y1 = wherey() ;
 
	for (cpt=1 ; cpt<n ; cpt++)
	{
		printf("\nValeur [%2d] : ", cpt) ;
	}
 
	for (cpt=0 ; cpt<n ; cpt++)
	{
		gotoxy (x1,y1) ;
		scanf ("%f", &x) ;
		tableau[cpt] = x ;
		y1++ ;
	}
}
 
/*****************/
/* Affichage du menu */
/*****************/
int menu ()
{
	int b, x0, y0 ;
 
	clrscr () ;
 
	printf("Menu\n") ;
	printf("ÍÍÍÍ\n\n") ;
 
	printf("1 --> Edition des valeurs\n") ;
	printf("2 --> Creation d'un fichier backup\n") ;
	printf("3 --> Lecture d'un fichier backup\n") ;
	printf("0 --> Quitter le programme\n\n") ;
	printf("\nFaites votre choix --> ") ;
	x0 = wherex() ;		y0 = wherey () ;
 
	do
	{
		gotoxy(x0,y0);
		clreol ();
		scanf("%d", &b);
 
	}while(b<0 || b>3) ;
 
	return (b) ;
}
 
/******************/
/* Edition des données */
/******************/
void edition (float *tableau, int n)
{
	int cpt ;
 
	clrscr () ;
 
	printf ("Edition des données\n") ;
	printf ("ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n") ;
 
	for (cpt=0 ; cpt<n ; cpt++)
	{
		printf ("\nLa valeur [%2d] : %.3f", cpt, *(tableau+cpt) ) ;
	}
	getch () ;
}
 
/*****************/
/* Création du fichier */
/*****************/
void ecriture (float *tableau, int n)
{
	char nom[50] ;
	FILE *ecriture ;
	clrscr () ;
 
	fflush (stdin) ;
 
	printf("Nom du fichier : ") ;
	gets(nom) ;
 
	ecriture = fopen(nom, "wb") ;
 
	fwrite (&n,sizeof(int),1,ecriture) ;
	fwrite (tableau, sizeof(float), n, ecriture) ;
 
	fclose(ecriture) ;
}
 
/****************/
/* Lecture du fichier */
/****************/
void lecture (float *tableau, int n)
{
	char nom[50] ;
	int cpt ;
	FILE *lecture ;
	clrscr () ;
 
	fflush (stdin) ;
 
	printf("Nom du fichier à lire : ") ;
	gets(nom) ;
 
	lecture = fopen(nom, "rb") ;
 
	fread (&n,sizeof(int),1,lecture) ;
 
	tableau = (float*)realloc(tableau, n*sizeof(float)) ;
 
             /* C'est ici qu'il y a un problème */
 
	fread (tableau, sizeof(float), n, lecture) ;
 
	fclose(lecture) ;
}

Remarques : Je crois que si je n'arrive pas à lire mon fichier c'est parce que je n'est pas de liaison entre la fonction principale et la fonction de lecture ! Mais je ne c'est pas comment m'y prendre ! Attention rien ne peut-être modifié dans le programme à part cette correction.

Merci de votre attention

Pour voir ce qui se passe:

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
 
void lecture (float *tableau, int n)
{
	char nom[50] ;
	int cpt ;
	FILE *lecture ;
	clrscr () ;
             int nlus ;
 
	fflush (stdin) ;
 
	printf("Nom du fichier à lire : ") ;
	gets(nom) ;
             printf("nom du fichier=>%s<\n", nom) ;
 
	lecture = fopen(nom, "rb") ;
             if (lecture == NULL) printf("erreur à l'ouverture du fichier\n") ;
 
	nlus = fread (&n,sizeof(int),1,lecture) ;
             printf("nlus=%d, n=%d\n", nlus, n) ;
 
	tableau = (float*)realloc(tableau, n*sizeof(float)) ;
             if (tableau == NULL) printf("erreur à l'allocation du tableau\n" );
 
             /* C'est ici qu'il y a un problème */
 
	nlus = fread (tableau, sizeof(float), n, lecture) ;
             printf("nlus=%d,", nlus) ;
 
	fclose(lecture) ;
}

Utiliser un débogueur permet également de savoir où se trouve l'erreur.

03/11/2007, 16h55
diogene

Bonjour et bienvenue dans la communauté DVP

Quelques remarques à la lecture de ton code :

Code:

void main (void)

main renvoie toujours un int

Code:

int main (void)

(optionnel) : Le switch de main devrait comporter une clause

Code:

default : break;

fonction valeur :
- tester la valeur de retour de scanf (qui doit être 1 dans ce cas)
- la condition du do while est a<=0 et retour de scanf != 1

fonction saisie :
- le pemier for est inutile
- tester la valeur de retour de scanf (qui doit être 1) dans ce cas, sinon recommencer

fonction menu
- tester le retour de scanf

fonction ecriture
- fflush ne peut s'appliquer à un flot d'entrée comme stdin mais uniquement à un flot de sortie. Voir à ce sujet la FAQ C
- ne jamais utiliser gets mais fgets sur stdin
- toujours tester si l'ouverture d'un fichier est correcte ( retour de fopen != NULL)

fonction lecture
- fflush ne peut s'appliquer à stdin
- tester le retour de fopen
- problème de realloc : mettre la valeur de retour dans une variable intermédiaire et tester le résultat à NULL. Si il est NULL, la réallocation a échoué et il reste l'ancien bloc alloué à sa place d'origine. Si elle a réussi, il est alors possible de copier cette valeur à la place de l'ancienne.
Dans ton programme, tu la copie dans tableau. Or tableau est une variable locale et ceci ne modifie pas la valeur dans le programme appelant (d'où ton problème). Deux solutions :
-la fonction renvoie la valeur de tableau (locale)
-la fonction prend pour argument float ** et on a * tableau = ...
Attention , realloc peut diminuer la taille du tableau ce qui peut entrainer la perte de donnée. Il faudrait gérer plus précisément la taille du tableau.

PS : pense aux balises CODE
03/11/2007, 17h02
Emmanuel Delahaye

Citation:

Envoyé par diogene

Le switch de main devrait comporter une clause

Code:

default : break;

Si c'est la dernière clause du switch, le break est superflu.
03/11/2007, 17h07
diogene

Citation:

Envoyé par Emmanuel Delahaye

Si c'est la dernière clause du switch, le break est superflu.

Oui. La clause default également, mais j'ai l'habitude de mettre default pour indiquer explicitement que d'autres valeurs sont possibles que celles listées dans les case. En relisant le message, j'avais oublié la mention "optionnel".
03/11/2007, 23h36
Sarter

Pouvez-vous me donner plus d'indication ?

Pourriez-vous me dire ce que je dois clairement faire car question fichier et vocabulaire du C je ne suis pas fort du tout :cry:

Je vous remercie de votre attention.
04/11/2007, 12h34
Emmanuel Delahaye

Citation:

Envoyé par Sarter

Pourriez-vous me dire ce que je dois clairement faire car question fichier et vocabulaire du C je ne suis pas fort du tout

Je pense que diogene a répondu. Si il y a des mots ou expressions que tu ne comprends pas, c'est le moment de poser des questions.
04/11/2007, 19h29
Sarter

Questions

Et Bien, comment puis-je renvoyer la valeur tableau tout simplement ?

Pouvez-vous me faire le détail ?

Merci beaucoup.

Je pense que ta question concerne la fonction lecture. On peut faire par exemple quelque chose suivant le modèle suivant : (la fonction renvoie un indicateur d'erreur pour indiquer au code appelant une erreur d'ouverture du fichier ou un échec de realloc)

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
int lecture (float **tableau, int n)
{
            ....
            FILE *lecture ;
            float *tab;
            int erreur = 0;
            ....	
           lecture = fopen(nom, "rb") ;
           erreur = lecture == NULL;
           if(! erreur)
           {	  
               tab = (float*)realloc(*tableau, n*sizeof(float)) ;
               erreur = tab == NULL;
               if(!erreur)
               {                 
                   *tableau = tab
                 ... 
 
               }
                 ...
	       fclose(lecture) ;
           }
  return erreur;
}

main :

Code:

1
2
case 3 : lecture (&tableau,n) ;
	 break ;

Néammoins, il reste un problème à résoudre : Combien d'éléments sont-ils alloués à un instant donné (problème évoqué en fin de mon premier message)

Bonjour,

j'ai pas tout lû.

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
/****************/
/* Lecture du fichier */
/****************/
void lecture (float *tableau, int n)
{
  char nom[50] ;
  int cpt,m ;
  FILE *lecture ;
  float *tab ;
  clrscr () ; // pourquoi !!!!
 
  fflush (stdin) ;
 
  printf("Nom du fichier à lire : ") ;
  gets(nom) ;
 
  lecture = fopen(nom, "rb") ;
 
  fread (&m,sizeof(int),1,lecture) ;
 
  tab = (float*)malloc(m*sizeof(float)) ; //pourquoi une  realloc !!!
 
   /* C'est ici qu'il y a un problème */
 
   fread (tab, sizeof(float), m, lecture) ;
	
   printf ("\nLa valeur de m = [%d] = ",m);
	
   for (cpt=0 ; cpt<m ; cpt++)
      printf ("\nLa valeur [%2d] : %.3f", cpt, *(tab+cpt) ) ;

   getchar(); //pour que tu puisse voir tes résultats
   fclose(lecture) ;

}

NB :

1- Essaie de donner des noms significatifs à tes variables.
2- il n' y a pas de gestion d'erreurs dans ton code !!!

Cordialement,

Turbo_chess

le header

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
154
155
156
157
 
/*-------------------------------------------------------------------------*/
/** 
** COMPOSANT     : 
**
** VERSION       : 
**
** CREE le       : 
**
** AUTEUR        : 
**
** MODIFIE le    : 
**      
** @DESCRIPTION  :  
**
** @END_ENTETE
**/
/* ------------------------------------------------------------------------*/
#ifndef EXEMPLE.H
#define EXEMPLE.H
/*---------------------------------------------------------------------------
** INCLUDES SYSTEMES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** INCLUDES APPLICATIFS
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** CONSTANTES GLOBALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** MACROS GLOBALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** TYPES GLOBAUX
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** VARIABLES GLOBALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** FONCTIONS GLOBALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
**
** FONCTION : getValue
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/
	int  getValue () ;
/*---------------------------------------------------------------------------
**
** FONCTION : dataEntry
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
	void dataEntry (float *tableau, int n) ;
/*---------------------------------------------------------------------------
**
** FONCTION : editData
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
	void editData (float *tableau, int n) ;
/*---------------------------------------------------------------------------
**
** FONCTION : mainMenu
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
	int  mainMenu () ;
/*---------------------------------------------------------------------------
**
** FONCTION : writingFile
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
	void writingFile (float *tableau, int n) ;
/*---------------------------------------------------------------------------
**
** FONCTION : readingFile
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/
	void readingFile () ;
#endif

Fichiers des fonctions

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
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
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
 
/*-------------------------------------------------------------------------*/
/** 
** COMPOSANT     : 
**
** VERSION       : 
**
** CREE le       : 
**
** AUTEUR        :  
**
** MODIFIE le    : 
**
** @DESCRIPTION  :  
**
** @END_ENTETE
**/
/* ------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------
** INCLUDES SYSTEMES
**---------------------------------------------------------------------------
*/
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include <stdlib.h>
/*---------------------------------------------------------------------------
** INCLUDES APPLICATIFS
**---------------------------------------------------------------------------
*/
#include "EXEMPLE.H"
/*---------------------------------------------------------------------------
** CONSTANTES LOCALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** MACROS LOCALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** TYPES LOCAUX
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** VARIABLES LOCALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** VARIABLES GLOBALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** PROTOTYPES DES FONCTIONS LOCALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** FONCTIONS LOCALES
**--------------------------------------------------------------------------- 
**/
 
/*---------------------------------------------------------------------------
**
** FONCTION : getValue
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
int getValue ()
{
	int a, x0, y0 ;
 
	printf ("Nombre de valeur à considérer > 0 : ") ;
	x0 = wherex () ;	y0 = wherey () ;
 
	do
	{
		gotoxy(x0,y0) ;
		clreol () ;
		scanf ("%d", &a) ;
 
	}while(a==0 || a<0) ;
 
	return (a) ;
}
 
/*---------------------------------------------------------------------------
**
** FONCTION : dataEntry
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
void dataEntry (float *tableau, int n)
{
	int x1, y1, cpt ;
	float x ;
 
	clrscr () ;
 
	printf ("Saisie des données\n") ;
 
	cpt = 0 ;
 
	printf("\nValeur [%2d] : ", cpt) ;
	x1 = wherex() ;		y1 = wherey() ;
 
	for (cpt=1 ; cpt<n ; cpt++)
	{
		printf("\nValeur [%2d] : ", cpt) ;
	}
 
	for (cpt=0 ; cpt<n ; cpt++)
	{
		gotoxy (x1,y1) ;
		scanf ("%f", &x) ;
		tableau[cpt] = x ;
		y1++ ;
	}
}
 
/*---------------------------------------------------------------------------
**
** FONCTION : mainMenu
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
int mainMenu ()
{
	int b, x0, y0 ;
 
	printf("Menu\n") ;
  clrscr();
	printf("1 --> Edition des valeurs\n") ;
	printf("2 --> Creation d'un fichier backup\n") ;
	printf("3 --> Lecture d'un fichier backup\n") ;
	printf("0 --> Quitter le programme\n\n") ;
	printf("\nFaites votre choix --> ") ;
	x0 = wherex() ;		y0 = wherey () ;
 
	do
	{
		gotoxy(x0,y0);
		clreol ();
		scanf("%d", &b);
 
	}while(b<0 || b>3) ;
 
	return (b) ;
}
 
/*---------------------------------------------------------------------------
**
** FONCTION : editData
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
void editData (float *tableau, int n)
{
	int cpt ;
 
	clrscr () ;
 
	printf ("Edition des données\n") ;
 
	for (cpt=0 ; cpt<n ; cpt++)
		printf ("\nLa valeur [%2d] : %.3f", cpt, *(tableau+cpt) ) ;
	getch () ;
}
 
/*---------------------------------------------------------------------------
**
** FONCTION : writingFile
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
void writingFile (float *tableau, int n)
{
	char nom[50] ;
	FILE *ecriture ;
	clrscr () ;
 
	fflush (stdin) ;
 
	printf("Nom du fichier : ") ;
	gets(nom) ;
 
	if ((ecriture = fopen(nom, "wb")) == NULL)
  {
   fprintf (stderr,"\n writingFile function - Cannot open file");
   exit (1);
  }
 
	fwrite (&n,sizeof(int),1,ecriture) ;
	fwrite (tableau, sizeof(float), n, ecriture) ;
 
	fclose(ecriture) ;
}
 
/*---------------------------------------------------------------------------
**
** FONCTION : readingFile
**
** DESCRIPTION :
**      Fonction 
**
** PARAMETRES D'ENTREE :
**	
**
** PARAMETRES DE SORTIE :
**	
**
** VALEURS DE RETOUR :
**
**---------------------------------------------------------------------------
*/	
void readingFile ()
{
	char nom[50] ;
	int cpt,m ;
	FILE *lecture ;
	float *tab ;
	clrscr () ;
 
	fflush (stdin) ;
 
	printf("Nom du fichier à lire : ") ;
	gets(nom) ;
 
	if ((lecture = fopen(nom, "rb")) == NULL)
  {
   fprintf (stderr,"\n writingFile function - Cannot open file");
   exit (1);
  }	
 
	fread (&m,sizeof(int),1,lecture) ;
 
	tab = (float*)malloc(m*sizeof(float)) ;
 
  /* C'est ici qu'il y a un problème */
 
	fread (tab, sizeof(float), m, lecture) ;
 
	for (cpt=0 ; cpt<m ; cpt++)
	{
		printf ("\nLa valeur [%2d] : %.3f", cpt, *(tab+cpt) ) ;
	}
  getch();
	fclose(lecture) ;
}

Fichier main

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
 
/*-------------------------------------------------------------------------*/
/** 
** COMPOSANT     : 
**
** VERSION       : 
**
** CREE le       : 
**
** AUTEUR        :  
**
** MODIFIE le    : %PRT%
**
** @DESCRIPTION  :  
**      
**
** @END_ENTETE
**/
/* ------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------
** INCLUDES SYSTEMES
**---------------------------------------------------------------------------
*/
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include <stdlib.h>
 
/*---------------------------------------------------------------------------
** INCLUDES APPLICATIFS
**---------------------------------------------------------------------------
*/ 
#include "EXEMPLE.H"
#include "EXEMPLE.C"
/*---------------------------------------------------------------------------
** CONSTANTES LOCALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** MACROS LOCALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** TYPES LOCAUX
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** VARIABLES LOCALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** VARIABLES GLOBALES
**---------------------------------------------------------------------------
*/
/*---------------------------------------------------------------------------
** FONCTIONS GLOBALES
**---------------------------------------------------------------------------
*/ 
int main (void)
{
 
	int G_arrayLength, choiceMainMenu ;
	float *G_arrayData ;
 
	clrscr() ;
 
	G_arrayLength = getValue () ;
	if ((G_arrayData = (float*)malloc(G_arrayLength*sizeof(float))) == NULL)
	{
	 printf("Problème d'allocation du tableau [G_arrayData]");
	 exit (1);
  }
  else
      printf ("Allocation du tableau G_arrayData avec [%d] elements",(int)G_arrayLength);
	dataEntry (G_arrayData, G_arrayLength) ;
 
	do
	{
		choiceMainMenu = mainMenu () ;
 
		switch (choiceMainMenu)
		{
 
			case 1 : editData (G_arrayData, G_arrayLength) ;
					     break ;
 
			case 2 : writingFile (G_arrayData, G_arrayLength) ;
					     break ;
 
			case 3 : readingFile () ;
					      break ;
		}
	}
  while(choiceMainMenu !=0) ;
  return (1);
}

NB : tu utilise TC ????