parsing et problème de type

Version imprimable

Voir 40 message(s) de cette discussion en une page

bonjour,

je veux faire du parsing de .csv afin de stocker le fichier dans un tableau. En gros j'ai des colonnes séparé par des ','. Ces colonnes comportent soit des nombre (scanné comme double) soit des chaines de caractères entre " ".

J'ai codé en supposant que toutes les colonnes sont des double. Je peux facilement détecter des chaine de caractères mais je ne vois pas comment gérer une allocation dynamique.

voici mon code (les chaine ne sont pas gérées) :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
void erreur_memoire(void)
{
	printf("Erreur Mémoire\n");
	exit(1);
}
 
void info_fichier(const char *fichier, int *nb_lignes, int *nb_colonnes, int *nb_lignes_vides, char separateur, char separateur_texte)
{
	char c;
	int nb_sep_total;
	FILE *f;
 
	if ( f=fopen(fichier,"rt") )
	{
		c=fgetc(f);
 
		nb_sep_total=0;
		*nb_lignes=0;
		*nb_colonnes=1;
		while( c!=EOF )
		{
			if ( c==separateur && *nb_lignes==0 && nb_colonnes )
				(*nb_colonnes)++;
			if ( c=='\n' && nb_lignes )
				(*nb_lignes)++;
 
			if ( c==separateur && nb_lignes )
				nb_sep_total++;
			c=fgetc(f);
		}
 
		if (nb_lignes_vides)
			*nb_lignes_vides=((*nb_colonnes-1)*(*nb_lignes)-nb_sep_total)/(*nb_colonnes-1);
 
		fclose(f);
	}
}
 
void printf_tableau(int nb_lignes, int nb_colonnes, double **tableau)
{
	int i,j;
 
	for(i=0;i<nb_lignes;i++)
	{
		for(j=0;j<nb_colonnes;j++)
			printf("%.1lf    ",tableau[i][j]);
		printf("\n");
	}
}
 
/* renvoie -1 si la ligne est vide 0 sinon */
int enregistre_ligne(double **sortie, char *buffer,int ligne_courante, int nb_lignes, int nb_colonnes, char separateur, char separateur_texte)
{
	int nb_sep=0;
	char *courant_debut=buffer, *courant_fin=NULL, *nombre;
	size_t lg;
 
	while(nb_sep!=nb_colonnes-1)
	{
		if ( courant_fin=strchr(courant_debut,separateur) )
		{
			lg=sizeof(courant_fin-1-courant_debut);
 
			if ( !(nombre=(char *)malloc(lg)) )
				erreur_memoire();
 
			strncpy(nombre,courant_debut, lg);
			if (strlen(nombre))
				sortie[ligne_courante][nb_sep]=atof(nombre);
			else
				return -1;
 
			courant_debut=courant_fin+sizeof(char);
			nb_sep++;
			free(nombre);
		}
		else
		{
			sortie[ligne_courante][nb_sep]=0.0;
			nb_sep++;
		}
	}
 
	if ( courant_fin=strchr(courant_debut,'\0') )
	{
 
		lg=sizeof(courant_fin-1-courant_debut);
		if ( !(nombre=(char *)malloc(lg)) )
			erreur_memoire();
 
		strncpy(nombre,courant_debut, lg);
		if (strlen(nombre))
			sortie[ligne_courante][nb_sep]=atof(nombre);
		else
			sortie[ligne_courante][nb_sep]=0.0;
 
		free(nombre);
	}
	else
	{
		sortie[ligne_courante][nb_sep]=0.0;
		nb_sep++;
	}
 
	return 0;
}
 
/* retourne -1 si erreur 0 sinon */
double **lecture_cvs(const char *fichier, int nbl, int nbc, char separateur, char separateur_texte)
{
	FILE *f;
	int ligne, i, nb_char;
	char *buf,c;
	double **sortie;
 
 
	/* On alloue le tableau de sortie */
	/* les colonnes */
	if ( !(sortie=(double **)malloc(sizeof(double)*nbl)) )
		erreur_memoire();
 
	/* les lignes */
	for (i=0;i<nbl;i++)
		if ( !(sortie[i]=(double *)malloc(sizeof(double)*nbc)) )
			erreur_memoire();
 
	if ( f=fopen(fichier,"rt") )
	{
		/* On initialise la ligne courante du tableau */
		ligne=0;
		for(i=0;i<nbl;i++)
		{
			c=fgetc(f);
			nb_char=1;
			while(c!='\n' && c!=EOF)
			{
				c=fgetc(f);
				nb_char++;
			}
			if ( !(buf=(char *)malloc(sizeof(char)*(nb_char+1))) )
				exit(1);
			fseek(f,-nb_char,SEEK_CUR);
 
			fscanf(f,"%s\n",buf); /* on récupére dans le buffer la ligne courante */
 
			/* on écrit la ligne contenue dans le buffer dans le tableau de sortie.
			   Si la ligne est vide on n'imcrémente pas ligne donc on réécrira dessus au prochain tour de boucle */
			if (enregistre_ligne(sortie,buf,ligne,nbl,nbc, separateur, separateur_texte)!=-1) 
				ligne++;
 
			free(buf);
		}
		fclose(f);
	}
	else
		return NULL;
 
	return sortie;
}
 
void libere_tableau(int nb_lignes, double **tableau)
{
	int i;
 
	for(i=0;i<nb_lignes;i++)
		free(tableau[i]);
	free(tableau);
}
 
int main(int argc, char **argv)
{
	double **tableau;
	char sep=',', texte='\"';
	int nbl,nbc,nblv;
 
	info_fichier("fichier.csv",&nbl,&nbc,&nblv,sep,texte);
	printf("%d-%d-%d\n",nbl,nbc,nblv);
 
	nbl=nbl-nblv;
	tableau=lecture_cvs("fichier.csv",nbl,nbc,sep,texte);
	printf_tableau(nbl,nbc,tableau);
	libere_tableau(nbl,tableau);
 
	return EXIT_SUCCESS;
}

compliqué le code
Je te propose plutot d'utiliser fgets et strtok pour séparer tes valeurs

Pour la fonction de lecture du fichier

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
// ouvrir le fichier csv
 
// pour toujours
for(;;)
{
   // lire une ligne
   char buffer(4096]
   char *ptr = fgets(desc_fichier, buffer, sizeof(buffer));
   // test fin de fichier, si oui, sortir de la boucle "pour toujours"
   if(ptr == NULL) break;
 
   // analyse de la ligne lue
   parse_ligne(buffer);
}
// fin pour toujours
 
// fermer le fichier csv

Pour la fonction de séparation des mots avec caractere "," comme separateur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
fonction parse_ligne(char *Ligne)
{
   // extraction du premier mot
   char *ptr = strtok(ligne, ",");
 
   // tant qu'il y a un mot
   while(ptr != NULL)
   {
      // traitement du mot pointe par ptr, transformation en double ou en vrai mot si il y a un caractère "
      // c'est ici que du as du traitement à faire
 
      // lecture du mot suivant
      ptr = strtok(NULL, ",");
   }
}

Voila dans les grandes lignes

je ne comprend pas bien l'utilisation de strtok :

Citation:

char *strtok (char *s, const char *t);

Cette fonction décompose la chaîne s en sous-chaîne délimitées par un caractère appartenant à ct. Un appel ultérieur à strtok avec s égale à NULL, retourne la sous-chaîne suivante ; ct peut être différent à chaque appel.
La chaîne passée en argument est modifiée par la fonction : elle ajoute un caractère de fin de chaîne à la place du séparateur.

donc en gros je fait :

Code:

1
2
3
4
strtok(buffer,',');
.....
strtok(NULL,',');
...etc

mais le dernier "mot" est entre ',' et '\n'. Comment je le gère ?

Enfin j'avais continuer mon code précédent avant de voir la réponse de ram_0000, il marche sous linux : le nombre sont bien stockées et les chaines sont stocké sous la valeur -2 mais en voulant compiler sous windows, j'ai une erreur de segmentation à l'éxécution, apparemment la ligne (dans enregistre_ligne) :

Code:

courant_debut=courant_fin+1;

pose problème.

voici le code auquel j'étais arrivé :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
void erreur_memoire(void)
{
	printf("Erreur Mémoire\n");
	exit(1);
}
 
void fichier_non_trouve(void)
{
	printf("fichier non trouvé\n");
}
 
void info_fichier(const char *fichier, int *nb_lignes, int *nb_colonnes, int *nb_lignes_vides, char separateur, char separateur_texte)
{
	char c;
	int nb_sep;
	FILE *f;
 
	if ( f=fopen(fichier,"rt") )
	{
		c=fgetc(f);
 
		nb_sep=0;
		if (nb_lignes)
			*nb_lignes=0;
		if(nb_colonnes)
			*nb_colonnes=1;
		if(nb_lignes_vides)
			*nb_lignes_vides=0;
 
		while( c!=EOF )
		{
			if ( c=='\n' && nb_lignes )
				(*nb_lignes)++;
 
			if ( c==separateur && *nb_lignes==1 && nb_colonnes )
				(*nb_colonnes)++;
 
			if( c==separateur )
				nb_sep++;
 
			c=fgetc(f);
		}
		(*nb_lignes_vides)=((*nb_colonnes-1)*(*nb_lignes)-nb_sep)/(*nb_colonnes-1);
 
		fclose(f);
	}
	else
	{
		*nb_lignes=0;
		*nb_colonnes=0;
		*nb_lignes_vides=0;
		fichier_non_trouve();
	}
}
 
void printf_tableau(int nb_lignes, int nb_colonnes, double **tableau)
{
	int i,j;
 
	printf("\n");
	for(i=0;i<nb_lignes;i++)
	{
		printf("ligne %2.2d : ",i+1);
		for(j=0;j<nb_colonnes;j++)
			printf("%2.1lf    ",tableau[i][j]);
		printf("\n");
	}
	printf("\n");
}
 
void copieNchar(char **s, char *e, size_t l)
{
	int i;
 
	if ( !(*s=(char *)malloc(l)) )
		erreur_memoire();
 
	for(i=0;i<l;i++)
	{
		if (e[i]!='\0')
			*(*s+i)=*(e+i);
		else
			return;
	}
 
	*(*s+i-1)='\0';
}
 
void analyse_attribut(double **sortie, int ligne_courante, int nb_sep, char *courant_debut, char *courant_fin, char separateur, char separateur_texte)
{
	char *texte_deb, *texte_fin, *attribut;
	size_t lg, car;
 
	car=sizeof(char);
	if (courant_fin)
	{
		texte_deb=strchr(courant_debut,separateur_texte);
 
		if ( courant_debut!=texte_deb || !texte_deb ) /* la zone est un nombre */
		{
			lg=(courant_fin-courant_debut+1)*car;
 
			copieNchar(&attribut,courant_debut, lg);
 
			sortie[ligne_courante][nb_sep]=atof(attribut);
		}
		else /* la zone représente du texte */
		{
			texte_fin=strchr(texte_deb+1,separateur_texte);
			lg=(texte_fin-texte_deb)*car;
 
			copieNchar(&attribut,texte_deb+1, lg);
 
			sortie[ligne_courante][nb_sep]=-2;
		}
		free(attribut);
	}
	else /* erreur */
		sortie[ligne_courante][nb_sep]=-1.0; 
}
 
void enregistre_ligne(double **sortie, char *buffer,int ligne_courante, int nb_lignes, int nb_colonnes, char separateur, char separateur_texte)
{
	int nb_sep;
	char *courant_debut, *courant_fin;
 
	courant_debut=buffer;
	nb_sep=0;
 
	while(nb_sep!=nb_colonnes-1)
	{
		courant_fin=strchr(courant_debut,separateur);
 
		analyse_attribut(sortie,ligne_courante,nb_sep,courant_debut,courant_fin,separateur,separateur_texte);
 
		courant_debut=courant_fin+1;
		nb_sep++;
	}
 
	/* Le dernier attribut finit la chaîne */
	courant_fin=strchr(courant_debut,'\0');
	analyse_attribut(sortie,ligne_courante,nb_sep,courant_debut,courant_fin,separateur,separateur_texte);
}
 
double **lecture_cvs(const char *fichier, int nbl, int nbc, char separateur, char separateur_texte)
{
	FILE *f;
	int ligne, i, nb_char;
	char *buf,c;
	double **sortie;
 
 
	/* On alloue le tableau de sortie */
	/* les colonnes */
	if ( !(sortie=(double **)malloc(sizeof(double)*nbl)) )
		erreur_memoire();
 
	/* les lignes */
	for (i=0;i<nbl;i++)
		if ( !(sortie[i]=(double *)malloc(sizeof(double)*nbc)) )
			erreur_memoire();
 
	if ( f=fopen(fichier,"rt") )
	{
		/* On initialise la ligne courante du tableau */
		ligne=0;
		for(i=0;i<=nbl;i++)
		{
			/* On calcule la longueur de la ligne */
			c=fgetc(f);
			nb_char=1;
			while(c!='\n' && c!=EOF)
			{
				c=fgetc(f);
				nb_char++;
			}
 
			/* on écrit la ligne contenue dans le buffer dans le tableau de sortie.
			   Si la ligne est vide on n'imcrémente pas ligne donc on réécrira dessus au prochain tour de boucle */
			if ( nb_char>nbc-1 )  /* Il y a bien nbc colonnes */
			{
				/* On alloue un buffer de la longueur correspondante à la ligne */
				if ( !(buf=(char *)malloc(sizeof(char)*(nb_char+1))) )
					erreur_memoire();
 
				/* On se replace au début de la ligne */
				fseek(f,-nb_char,SEEK_CUR);
 
				/* On mets dans le buffer la ligne */
				fscanf(f,"%s\n",buf); /* on récupére dans le buffer la ligne courante */
 
				enregistre_ligne(sortie,buf,ligne,nbl,nbc,separateur,separateur_texte);
				free(buf);
 
				ligne++;
			}
		}
		fclose(f);
	}
	else
	{
		fichier_non_trouve();
		return NULL;
	}
 
	return sortie;
}
 
void libere_tableau(int nb_lignes, double **tableau)
{
	int i;
 
	for(i=0;i<nb_lignes;i++)
		free(tableau[i]);
	free(tableau);
}
 
/* renvoi une ligne pour min et une pour max contenant les min et max de la colonne correspondante.
Pour le moement, le tableau ne doit comporter que des chiffres. 
Il faut penser à faire un free sur min et max après utilisation. */
void extremum(double **tableau, int nb_lignes, int nb_colonnes, double *min, double *max)
{
	int i,j;
 
 
	for(i=0;i<nb_colonnes;i++)
	{
		min[i]=tableau[0][i];
		max[i]=tableau[0][i];
	}
 
	for(i=1;i<nb_lignes;i++)
	{
		for(j=0;j<nb_colonnes;j++)
		{
			if (tableau[i][j]<min[j])
				min[j]=tableau[i][j];
			if (tableau[i][j]>max[j])
				max[j]=tableau[i][j];
		}
	}
}
 
int main(int argc, char **argv)
{
	double **tableau, min[200], max[200];
	char sep=',', texte='\"';
	int nbl,nbc,nblv,i;
 
	if (argc<2)
	{
		printf("Ce programme s'utilise comme suit :\n./main fichier.csv\n");
		return -1;
	}
 
	printf("\nInformations sur le fichier :\n");
	printf("-----------------------------\n");
	info_fichier(argv[1],&nbl,&nbc,&nblv,sep,texte);
	printf("\nNombre de lignes : %d\nNombre de colonnes :%d\nNombre de lignes vides :%d\n\n",nbl,nbc,nblv);
 
	nbl=nbl-nblv;
 
	tableau=lecture_cvs(argv[1],nbl,nbc,sep,texte);
 
	if (tableau)
	{
		printf("Légende :\n");
		printf("---------\n");
		printf("-1 : erreur de lecture\n");
		printf("-2 : texte\n");
		printf("Autre : valeur numérique affichée à 1 décimale\n");
		printf("\n");
 
		printf_tableau(nbl,nbc,tableau);
 
		extremum(tableau, nbl,nbc,min,max);
 
		printf("mins : ");
		for(i=0;i<nbc;i++)
			printf("%3.1lf  ",min[i]);
		printf("\n");
 
		printf("maxs : ");
		for(i=0;i<nbc;i++)
			printf("%3.1lf  ",max[i]);
		printf("\n");
 
		printf("\n");
 
		libere_tableau(nbl,tableau);
	}
 
	return EXIT_SUCCESS;
}

edit : je n'ai toujours pas trouvé comment avoir un mélange de char et de double dans mon tableau. J'ai pensé à utiliser une variable char *type qui renvéré une suite de %d et %s mais je ne vois pas comment géré l'allocation.

je n'ai modifié que enregistre_ligne avec des strtok :

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
void enregistre_ligne(double **sortie, char *buffer,int ligne_courante, int nb_lignes, int nb_colonnes, char separateur, char separateur_texte)
{
	int nb_sep;
	char *attribut;
 
	nb_sep=0;
 
	attribut=strtok(buffer, ","); /* Remplace les ',' par des '\0', le dernier argument se termine déjà par '\0' donc c'est bon */
 
	while(nb_sep!=nb_colonnes)
	{
		if (attribut)
		{
			if (strlen(attribut)==0)
				printf("zero\n\n");
			if ( *attribut!=separateur_texte) /* c'est un nombre */
			{
				sortie[ligne_courante][nb_sep]=atof(attribut);
			}
			else /* c'est un texte */
			{
				sortie[ligne_courante][nb_sep]=-2.0;
			}
		}
		else /* attribut pointe sur rien */
		{
			sortie[ligne_courante][nb_sep]=-1.0;
		}
 
		attribut=strtok(NULL, ",");
		nb_sep++;
	}
}
 
double **lecture_csv(const char *fichier, int nbl, int nbc, char separateur, char separateur_texte)
{
	FILE *f;
	int ligne, i, nb_char;
	char *buf,c;
	double **sortie;
 
 
	/* On alloue le tableau de sortie */
	/* les colonnes */
	if ( !(sortie=(double **)malloc(sizeof(double)*nbl)) )
		erreur_memoire();
 
	/* les lignes */
	for (i=0;i<nbl;i++)
		if ( !(sortie[i]=(double *)malloc(sizeof(double)*nbc)) )
			erreur_memoire();
 
	if ( f=fopen(fichier,"rt") )
	{
		/* On initialise la ligne courante du tableau */
		ligne=0;
		for(i=0;i<=nbl;i++)
		{
			/* On calcule le nombre de caractères de la ligne */
			c='0';
			nb_char=0;
			while(c!='\n' && c!=EOF)
			{
				c=fgetc(f);
				nb_char++;
			}
 
			/* on écrit la ligne contenue dans le buffer dans le tableau de sortie.
			   Si la ligne est vide on n'imcrémente pas ligne donc on réécrira dessus au prochain tour de boucle */
			if ( nb_char>nbc-1 )  /* Il y a bien nbc colonnes */
			{
				/* On alloue un buffer de la longueur correspondante à la ligne */
				if ( !(buf=(char *)malloc(sizeof(char)*(nb_char+1))) )
					erreur_memoire();
 
				/* On se replace au début de la ligne */
				fseek(f,-nb_char,SEEK_CUR);
 
				/* On mets dans le buffer la ligne */
				fscanf(f,"%s\n",buf); /* on récupére dans le buffer la ligne courante */
 
				enregistre_ligne(sortie,buf,ligne,nbl,nbc,separateur,separateur_texte);
				free(buf);
 
				ligne++;
			}
		}
		fclose(f);
	}
	else
	{
		fichier_non_trouve();
		return NULL;
	}
 
	return sortie;
}

j'ai des soucis avec mon fichier de test :

Citation:

1,"nom1",5,"colonne4.1"
2,"nom22",7,"colonne4.2"

2,"nonpl",7,"reine"
7,"nom7",17,"col4.7"
8,"nom8765432101234567890",19,"colonne4.8"
9,"nom9",21,"colonne4.9"
,"",," "
11,"nom11",25,"colonne4.11"
12,"nom12",27,"col4.12"

14,"nom14",31,"colonne4.14"
15,"nom15",33,"colonne4.15"

1) Si il y a un espace en haut (au début du fichier), la dernière ligne n'est pas enregistré.

2) Les lignes vides ne sont pas correctement gérer (la ligne : ,"",,""). La ligne est complète (il y a tous les champs) mais enregistre_ligne ne me renvoi que les zone vrément séparées par des virgules : si par exemple j'avais ques des nombre, je n'aurais rien (strtok en faute ?).

Bon j'ai revu mes idées à la baisse, je me satisfait maintenant d'un fichier ne contenant que des nombres.

J'ai tout de même un souci puisque comme je l'ai dit plus haut quand j'ai une ligne qui ne comporte pas de valeurs, je ne peut pas mettre 0 (comme je le voudrais) :

si j'ai ",,," je voudrais l'interprété comme "0,0,0", de même si j'ai ",6," je voudrais l'interprété comme "0,6,0".

Apperemment la fonction strtok ne renvoi que le premier '\0' tel que le caractère suivant ne soit pas '\0', comme récupérer le premier simplement ?
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 void enregistre_ligne(double **sortie, char *buffer,int ligne_courante, int nb_lignes, int nb_colonnes, char separateur, char separateur_texte) { int nb_sep; char *attribut; nb_sep=0; attribut=strtok(buffer, ","); /* Remplace les ',' par des '\0', le dernier argument se termine déjà par '\0' donc c'est bon */ while(nb_sep!=nb_colonnes) { if (attribut) { if (!strlen(attribut)) printf("zero\n\n"); if ( *attribut!=separateur_texte) /* c'est un nombre */ { sortie[ligne_courante][nb_sep]=atof(attribut); } else /* c'est un texte */ { sortie[ligne_courante][nb_sep]=-2.0; } } else /* attribut pointe sur rien */ { sortie[ligne_courante][nb_sep]=-1.0; } attribut=strtok(NULL, ","); nb_sep++; } }

18/01/2008, 16h30
Médinoc

En fait, si tu peux contrôler le format du fichier, je te conseillerais de renoncer carrément au format CSV, qui complique les choses avec les guillemets.

Je viens de lire cet article en Anglais, qui dit que le format passwd est plus simple et plus aisé à gérer...
18/01/2008, 17h19
Rniamo

pas le choix :(, mais j'ai abandonné les champs de texte, j'en ai pas vraiment besoin. Par contre strtok ne me permet pas de récupérer des champs laisser vide, je ne vois pas comment faire.
18/01/2008, 17h21
Médinoc

À part faire ta propre implémentation, je ne vois pas trop...

bon si la ligne ne contient pas tous les champs je ne la prend plus en compte mais j'ai un nouveau problème : le code marche sous linux (enfin sur mon pc au moins) mais pas sous windows ...

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
void erreur_memoire(void)
{
	printf("Erreur Mémoire\n");
	exit(1);
}
 
void fichier_non_trouve(void)
{
	printf("fichier non trouvé\n");
}
 
void info_fichier(const char *fichier, int *nb_lignes, int *nb_colonnes, int *nb_lignes_vides, char separateur)
{
	char c;
	int nb_sep, cpt_col;
	FILE *f;
 
	if ( f=fopen(fichier,"rt") )
	{
		c=fgetc(f);
 
		nb_sep=0;
		cpt_col=1;
 
		if (nb_lignes)
			*nb_lignes=0;
		if(nb_colonnes)
			*nb_colonnes=0;
		if(nb_lignes_vides)
			*nb_lignes_vides=0;
 
		while( c!=EOF )
		{
			if ( c=='\n' && nb_lignes )
				(*nb_lignes)++;
 
			if ( c==separateur && nb_colonnes && cpt_col )
				(*nb_colonnes)++;
 
			if ( cpt_col && c==	'\n' && (*nb_colonnes) )
				cpt_col=!cpt_col;
 
			if( c==separateur )
				nb_sep++;
 
			c=fgetc(f);
		}
		(*nb_colonnes)++;
		(*nb_lignes_vides)=((*nb_colonnes-1)*(*nb_lignes)-nb_sep)/(*nb_colonnes-1);
 
		fclose(f);
	}
	else
	{
		*nb_lignes=0;
		*nb_colonnes=0;
		*nb_lignes_vides=0;
		fichier_non_trouve();
	}
}
 
void printf_tableau(int nb_lignes, int nb_colonnes, double **tableau)
{
	int i,j;
 
	printf("\n");
	for(i=0;i<nb_lignes;i++)
	{
		printf("ligne %2.2d : ",i+1);
		for(j=0;j<nb_colonnes;j++)
			printf("%g    ",tableau[i][j]);
		printf("\n");
	}
	printf("\n");
}
 
void enregistre_ligne(double **sortie, char *buffer,int ligne_courante, int nb_lignes, int nb_colonnes, char separateur)
{
	int nb_sep,i,deb;
	char *attribut, sep[2];
 
	nb_sep=0;
 
 
	attribut=strtok(buffer, ",\0"); 
 
	while(attribut!=NULL)
	{
		sortie[ligne_courante][nb_sep]=atof(attribut);
		attribut=strtok(NULL, ",");
		nb_sep++;
	}
}
 
int analyse_ligne(char *buffer, char separateur)
{
	char c1,c2;
	int i;
 
	if (strlen(buffer)<2)
		return -1;
 
	i=0;
	while( i<(strlen(buffer)-1) )
	{
		if (buffer[i]==buffer[i+1] && buffer[i]==separateur)
			return -1;
 
		i++;
	}
 
	return 0;
}
 
double **lecture_cvs(const char *fichier, int nbl, int nbc, char separateur, int *ligne_tableau)
{
	FILE *f;
	int ligne, i, nb_char, nb_sep;
	char *buf,c;
	double **sortie;
 
	if ( !(sortie=(double **)malloc(sizeof(double *)*nbl)) )
		erreur_memoire();
 
	if ( f=fopen(fichier,"rt") )
	{
		/* On initialise la ligne courante du tableau */
		ligne=0;
		for(i=0;i<=nbl;i++)
		{
			/* On calcule le nombre de caractères de la ligne */
			c=fgetc(f);
			nb_char=1;
			nb_sep=0;
			while(c!='\n' && c!=EOF)
			{
				if (c==separateur)
					nb_sep++;
				c=fgetc(f);
				nb_char++;
			}
 
			/* on écrit la ligne contenue dans le buffer dans le tableau de sortie.
			   Si la ligne est vide on n'imcrémente pas ligne donc on réécrira dessus au prochain tour de boucle */
			if ( nb_sep==(nbc-1) )
			{
				fseek(f,-nb_char,SEEK_CUR);
 
				if ( !(buf=(char *)malloc(sizeof(char)*(nb_char+1))) )
					erreur_memoire();
 
				fscanf(f,"%s\n",buf); /* on récupére dans le buffer la ligne courante */
 
				if (buf && !analyse_ligne(buf, separateur))
				{
					if ( !(sortie[ligne]=(double *)malloc(sizeof(double)*nbc)) )
						erreur_memoire();
 
					enregistre_ligne(sortie,buf,ligne,nbl,nbc,separateur);
					free(buf);
					ligne++;
				}
			}
		}
		fclose(f);
	}
	else
	{
		fichier_non_trouve();
		if (ligne_tableau)
			*ligne_tableau=0;
		return NULL;
	}
 
	if ( !(sortie=(double **)realloc(sortie,sizeof(double *)*ligne)) )
		erreur_memoire();
 
	if (ligne_tableau)
		*ligne_tableau=ligne;
 
	return sortie;
}
 
void libere_tableau(int nb_lignes, double **tableau)
{
	int i;
 
	for(i=0;i<nb_lignes;i++)
		free(tableau[i]);
	free(tableau);
}
 
/* renvoi une ligne pour min et une pour max contenant les min et max de la colonne correspondante.
Pour le moement, le tableau ne doit comporter que des chiffres. 
Il faut penser à faire un free sur min et max après utilisation. */
void extremum(double **tableau, int nb_lignes, int nb_colonnes, double *min, double *max)
{
	int i,j;
 
 
	for(i=0;i<nb_colonnes;i++)
	{
		min[i]=tableau[0][i];
		max[i]=tableau[0][i];
	}
 
	for(i=1;i<nb_lignes;i++)
	{
		for(j=0;j<nb_colonnes;j++)
		{
			if (tableau[i][j]<min[j])
				min[j]=tableau[i][j];
			if (tableau[i][j]>max[j])
				max[j]=tableau[i][j];
		}
	}
}
 
int main(int argc, char **argv)
{
	double **tableau, min[200], max[200];
	char sep=',', texte='\"';
	int nbl,nbc,nblv,nblt,i;
 
	if (argc<2)
	{
		printf("Ce programme s'utilise comme suit :\n./main fichier.csv\n");
		return -1;
	}
 
	printf("\nInformations sur le fichier :\n");
	printf("-----------------------------\n");
	info_fichier(argv[1],&nbl,&nbc,&nblv,sep);
	printf("\nNombre de lignes : %d\nNombre de colonnes :%d\nNombre de lignes vides :%d\n\n",nbl,nbc,nblv);
 
 
 
	tableau=lecture_cvs(argv[1],nbl,nbc,sep,&nbl);
 
	if (tableau)
	{
		printf("\nLégende :\n");
		printf("---------\n");
		printf("-1 : erreur de lecture\n");
		printf("-2 : texte\n");
		printf("Autre : valeur numérique\n");
		printf("N.B. : cette version de la librairie ne prend pas en compte les chaines de caractères\n");
		printf("\n");
 
		printf_tableau(nbl,nbc,tableau);
 
		extremum(tableau, nbl,nbc,min,max);
 
		printf("mins : ");
		for(i=0;i<nbc;i++)
			printf("%3.1lf  ",min[i]);
		printf("\n");
 
		printf("maxs : ");
		for(i=0;i<nbc;i++)
			printf("%3.1lf  ",max[i]);
		printf("\n");
 
		printf("\n");
 
		libere_tableau(nbl,tableau);
	}
 
	return EXIT_SUCCESS;
}

La récupération des informations de tailles marche mais pas celles des données.

18/01/2008, 20h20
Médinoc
Je n'ai rien trouvé de flagrant qui pourrait expliquer ton erreur, mais j'ai quelques remarques:
1. Attention, le Else de info_fichier() ne vérifie pas les pointeurs.
2. Pour le prototype de printf_tableau(), je mettrais le dernier pointeur du type double const * const *, puisque tu ne modifies rien. Par contre, sur un compilo respectant le standard, il faudra un cast, contrairement au C++.
3. Le \0 dans le second paramètre de strtok() ne sert à rien.
4. enregistre_ligne() prend le nombre de colonnes en paramètre, mais ne s'en sert pas: Tu devrais t'en servir pour protéger ta matrice.
5. Ta fonction analyse_ligne(): son paramètre buffer devrait être un pointeur const.
6. On ne caste pas le retour de malloc() en C.
7. "rt" n'est pas standard. Pour lire un fichier texte, "r" suffit.
8. Mauvaise utilisation de realloc(). http://emmanuel-delahaye.developpez....es.htm#realloc
9. Es-tu absolument sûr que tous les pointeurs contenu dans le tableau sont toujours soit valides, soit nuls ?
10. Pour extremum, double const * const * aussi...
19/01/2008, 15h24
Rniamo

ça fait beaucoup de choses fort intéressantes.

J'ai tout de même deux remarques :

1) comme tu l'a dit, le const *const * oblige à caster et comme cette fonction ne me sert que pour tester le reste je ne m'en suis pas embarassé.

2) en ce qui concerne le "rt" et le castage du malloc, je suis d'accord avec tes remarques...mais comme il y a des chances que ça se retrouve dans un mini-projet officiel pour mon école et que dans le cours c'est marqué comme ça...je suis bêtement.

3) tu peux développez le problème avec mon realloc s'il te plait ? Je veux réduire la taille du tableau à celle rééllement utilisée.

Sinon il me reste toujours le cas de la ligne vide, il y a t-il une fonction qui permet de remplcer une chaîne par une autre qui gère l'allocation (l'appel serait par exemple : strrmp(s, ",,",",0,"); ?)

edit : sous windows le problème vient de :

Code:

fseek(f,-nb_char,SEEK_CUR);

mais je ne sais pas pourquoi, si je l'enlève ça marche (à l'exception près que je loupe une ligne sur deux comme on doit si attendre).
19/01/2008, 15h46
souviron34

parce que fseek prend un offset qui n'est pas -nchar ...

voir la doc..
19/01/2008, 15h48
Rniamo

l'offset est un long normalement et je mets un int donc ça devrait passer non ?
19/01/2008, 15h52
Emmanuel Delahaye

Citation:

Envoyé par Rniamo

l'offset est un long normalement et je mets un int donc ça devrait passer non ?

Peut-être. C'est pas portable.
19/01/2008, 15h59
Rniamo

j'ai mis un long, j'ai vérifié le prototype dans les include de dev-cpp (windows) et ça ne marche toujours pas.

voici mon code presque final (marche pas mal sur mon pc linux mais plante sous windows ) :

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
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void erreur_memoire(void)
{
	printf("Erreur Mémoire\n");
	exit(1);
}
 
void fichier_non_trouve(void)
{
	printf("fichier non trouvé\n");
}
 
void info_fichier(const char *fichier, int *nb_lignes, int *nb_colonnes, int *nb_lignes_vides, char separateur)
{
	char c;
	int nb_sep, cpt_col;
	FILE *f;
 
	if (nb_lignes)
		*nb_lignes=0;
	if(nb_colonnes)
		*nb_colonnes=0;
	if(nb_lignes_vides)
		*nb_lignes_vides=0;
 
	if ( f=fopen(fichier,"rt") )
	{
		c=fgetc(f);
 
		nb_sep=0;
		cpt_col=1;
 
;
 
		while( c!=EOF )
		{
			if ( c=='\n' && nb_lignes )
				(*nb_lignes)++;
 
			if ( c==separateur && nb_colonnes && cpt_col )
				(*nb_colonnes)++;
 
			if ( cpt_col && c==	'\n' && (*nb_colonnes) )
				cpt_col=!cpt_col;
 
			if( c==separateur )
				nb_sep++;
 
			c=fgetc(f);
		}
		(*nb_colonnes)++;
		(*nb_lignes_vides)=((*nb_colonnes-1)*(*nb_lignes)-nb_sep)/(*nb_colonnes-1);
 
		fclose(f);
	}
	else
		fichier_non_trouve();
}
 
void printf_tableau(int nb_lignes, int nb_colonnes, double **tableau)
{
	int i,j;
 
	printf("\n");
	for(i=0;i<nb_lignes;i++)
	{
		printf("ligne %2.2d : ",i+1);
		for(j=0;j<nb_colonnes;j++)
			printf("%g    ",tableau[i][j]);
		printf("\n");
	}
	printf("\n");
}
 
 
char *bouche_tours(char *e, char separateur, char remplacement)
{
     int i, j;
     char *s,*p, *v, rempl[2], sep[3];
     size_t taille;
 
	sep[0]=separateur;
	sep[1]=separateur;
	sep[2]='\0';
	rempl[0]=separateur;
	rempl[1]=remplacement;
	p=e;
 
	if ( !(s=(char *)malloc((2*strlen(e)+1)*sizeof(char))) )
		erreur_memoire();
	*s='\0';
 
	if (*e==separateur)
		strcat(s,&(rempl[1]));
 
     i=0;
     while(p!=(e+strlen(e)))
     {
     	v=strstr(p,sep);
		if (v==p)
			strcat(s,rempl);
		else
			strncat(s,p,1);
		p++;
     }
 
	if (*(e+strlen(e)-1)==separateur)
		strcat(s,&(rempl[1]));
 
	if (!(s=(char *)realloc(s,sizeof(char)*strlen(s))))
		 erreur_memoire();
 
  return s;
}
 
void enregistre_ligne(double **sortie, char *buffer,int ligne_courante, char separateur)
{
	int nb_sep,i,deb;
	char *attribut, sep[2];
 
	nb_sep=0;
 
 
	attribut=strtok(buffer, ","); 
 
	while(attribut!=NULL)
	{
		sortie[ligne_courante][nb_sep]=atof(attribut);
		attribut=strtok(NULL, ",");
		nb_sep++;
	}
}
 
double **lecture_cvs(const char *fichier, int nbl, int nbc, char separateur, int *ligne_tableau)
{
	FILE *f;
	int ligne, i, nb_char, nb_sep;
	char *buf1,c;
	double **sortie;
 
	if ( !(sortie=(double **)malloc(sizeof(double *)*nbl)) )
		erreur_memoire();
 
	if ( f=fopen(fichier,"rt") )
	{
		/* On initialise la ligne courante du tableau */
		ligne=0;
		for(i=0;i<=nbl;i++)
		{
			/* On calcule le nombre de caractères de la ligne */
			c=fgetc(f);
			nb_char=1;
			nb_sep=0;
			while(c!='\n' && c!=EOF)
			{
				if (c==separateur)
					nb_sep++;
				c=fgetc(f);
				nb_char++;
			}
 
			/* on écrit la ligne contenue dans le buffer dans le tableau de sortie.
			   Si la ligne est vide on n'imcrémente pas ligne donc on réécrira dessus au prochain tour de boucle */
			if ( nb_sep==(nbc-1) )
			{
				fseek(f,-nb_char,SEEK_CUR);
 
				if ( !(buf1=(char *)malloc(sizeof(char)*(nb_char))) )
					erreur_memoire();
 
				fscanf(f,"%s\n",buf1); /* on récupére dans le buffer la ligne courante */
				buf1=bouche_tours(buf1,separateur,'0');printf("%s\n",buf1);
 
				if ( !(sortie[ligne]=(double *)malloc(sizeof(double)*nbc)) )
					erreur_memoire();
 
				enregistre_ligne(sortie,buf1,ligne,separateur);
				free(buf1);
				ligne++;
			}
		}
		fclose(f);
	}
	else
	{
		fichier_non_trouve();
		if (ligne_tableau)
			*ligne_tableau=0;
		return NULL;
	}
 
	if ( !(sortie=(double **)realloc(sortie,sizeof(double *)*ligne)) )
		erreur_memoire();
 
	if (ligne_tableau)
		*ligne_tableau=ligne;
 
	return sortie;
}
 
void libere_tableau(int nb_lignes, double **tableau)
{
	int i;
 
	if (tableau)
	{
		for(i=0;i<nb_lignes;i++)
		{
			if (tableau[i])
				free(tableau[i]);
		}
		free(tableau);
	}
}
 
/* renvoi une ligne pour min et une pour max contenant les min et max de la colonne correspondante.
Pour le moement, le tableau ne doit comporter que des chiffres. 
Il faut penser à faire un free sur min et max après utilisation. */
void extremum(double **tableau, int nb_lignes, int nb_colonnes, double **mini, double **maxi)
{
	int i,j;
	double *min, *max;
 
	if (!(min=(double *)malloc(sizeof(double)*nb_colonnes)))
		erreur_memoire();
 
	if (!(max=(double *)malloc(sizeof(double)*nb_colonnes)))
		erreur_memoire();
 
	for(i=0;i<nb_colonnes;i++)
	{
		min[i]=tableau[0][i];
		max[i]=tableau[0][i];
	}
 
	for(i=0;i<nb_lignes;i++)
	{
		for(j=0;j<nb_colonnes;j++)
		{
			if (tableau[i][j]<min[j])
				min[j]=tableau[i][j];
			if (tableau[i][j]>max[j])
				max[j]=tableau[i][j];
		}
	}
 
	*mini=min;
	*maxi=max;
}
 
void libere_tout(double **tableau, double *min, double *max, int nbl)
{
	if (min)
		free(min);
	if (max)	
		free(max);
	if (tableau)
		libere_tableau(nbl,tableau);
}
 
void normalisation(double **tableau,double *min, double *max, int nbc, int nbl)
{
	int i,j;
	double EM;
 
	for(i=0;i<nbc;i++)
	{
		EM=max[i]-min[i];
		for(j=0;j<nbl;j++)
		{
			if (EM)
				tableau[j][i]=(tableau[j][i]-min[i])/EM;
		}
	}
}
 
int main(int argc, char **argv)
{
	double **tableau, *min, *max;
	char sep=',', texte='\"';
	int nbl,nbc,nblv,nblt,i;
 
	if (argc<2)
	{
		printf("Ce programme s'utilise comme suit :\n./main fichier.csv\n");
		return -1;
	}
 
	printf("\nInformations sur le fichier :\n");
	printf("-----------------------------\n");
	info_fichier(argv[1],&nbl,&nbc,&nblv,sep);
	printf("\nNombre de lignes : %d\nNombre de colonnes :%d\nNombre de lignes vides :%d\n\n",nbl,nbc,nblv);
 
	tableau=lecture_cvs(argv[1],nbl,nbc,sep,&nbl);
 
	if (tableau)
	{
		printf("\nLégende :\n");
		printf("---------\n");
		printf("-1 : erreur de lecture\n");
		printf("-2 : texte\n");
		printf("Autre : valeur numérique\n");
		printf("N.B. : cette version de la librairie ne prend pas en compte les chaines de caractères\n");
		printf("\n");
 
		printf_tableau(nbl,nbc,tableau);
 
		extremum(tableau,nbl,nbc,&min,&max);
 
		printf("mins : ");
		for(i=0;i<nbc;i++)
			printf("%g  ",min[i]);
		printf("\n");
 
		printf("maxs : ");
		for(i=0;i<nbc;i++)
			printf("%g  ",max[i]);
		printf("\n\n");
 
		normalisation(tableau,min,max,nbc,nbl);
 
		printf("Tableau Normalisé :\n");
		printf_tableau(nbl,nbc,tableau);
	}
 
	libere_tout(tableau,min,max,nbl);
	printf("mémoire libérée avec succès\n\n");
 
	return EXIT_SUCCESS;
}

J'ai toujours le défaut des const mais je crois avoirs corrigé le reste...enfin un peu ;).

Pouvez-vous me dir si ça marche ?

Le but : charger dans un tableau un csv numérique et le normaliser.

Citation:

Envoyé par Rniamo

voici mon code presque final (marche pas mal sur mon pc linux mais plante sous windows ) :

J'ai toujours le défaut des const mais je crois avoirs corrigé le reste...enfin un peu ;).

Pouvez-vous me dir si ça marche ?

Un meilleur réglage du compilateur devrait t'aider à corriger ce 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
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `info_fichier':
main.c:29: warning: suggest parentheses around assignment used as truth value
main.c: In function `bouche_tours':
main.c:81: warning: unused variable `j'
main.c:83: warning: unused variable `taille'
main.c: In function `enregistre_ligne':
main.c:121: warning: unused variable `i'
main.c:121: warning: unused variable `deb'
main.c:122: warning: unused variable `sep'
main.c: At top level:
main.c:119: warning: unused parameter 'separateur'
main.c: In function `lecture_cvs':
main.c:147: warning: suggest parentheses around assignment used as truth value
main.c: In function `main':
main.c:283: warning: unused variable `texte'
main.c:284: warning: unused variable `nblt'
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 10 warnings

19/01/2008, 17h03
Rniamo

(ok, je regarde)

et personne ne peut m'expliquer le problème de fseek sous windows?
19/01/2008, 17h39
diogene

n1124 dit :

Citation:

7.19.9.2 The fseek function
Synopsis
1 #include <stdio.h>
int fseek(FILE *stream, long int offset, int whence);

Description
2 The fseek function sets the file position indicator for the stream pointed to by stream.
If a read or write error occurs, the error indicator for the stream is set and fseek fails.

3 For a binary stream, ....

4 For a text stream, either offset shall be zero, or offset shall be a value returned by
an earlier successful call to the ftell function on a stream associated with the same file
and whence shall be SEEK_SET.
...
20/01/2008, 21h28
Rniamo

merci :)

Voir 40 message(s) de cette discussion en une page