parsing et problème de type

**Rniamo** · 17/01/2008, 17h45

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 :

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
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;
}

**ram-0000** · 17/01/2008, 18h44

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 :

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
 
// 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 :

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
 
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

**Rniamo** · 18/01/2008, 11h53

je ne comprend pas bien l'utilisation de strtok :

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 :

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

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 :

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

		courant_debut=courant_fin+1;

pose problème.

voici le code auquel j'étais arrivé :

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
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.

**Rniamo** · 18/01/2008, 14h20

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

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
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 :

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 ?).

**Rniamo** · 18/01/2008, 16h15

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 :

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
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++;
	}
}

**Médinoc** · 18/01/2008, 16h30

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...

parsing et problème de type

C

Vue hybride

Discussions similaires

Partager

Partager