Implémenter un nom de fichier en C

Version imprimable

Incrémenter un nom de fichier en C

Bonjour,

Besoin d'incrémenter un nom de fichier en C mais ça paraît compliqué.

J'ai écris ce bout de code pour illustrer mes propos :

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
 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define size 200
//#define ncorps 10
 
 
main ()
{
int k;                       // indice du corps solide
int ncorps;                  // nombre de corps solides dans mon systeme
int compteur;                // le compteur
int maxcompteur;             // nombre max d'itérations
int sauv;                    // fréquence de sauvegarde
double dt,temps;
double x[size]={0};          // la valeur à calculer et à sauvegarder 
                             // pour chaque corps
                             // supposons ici qu'elle est connue
FILE*fichier;      
 
 
dt=0.000001;
temps=0;
ncorps=5;
sauv=2;
maxcompteur=10;
compteur=1;
 
fichier=fopen("resu.dat","w");
 
 
 
 do{
 
		if(compteur%sauv==0){
		    fprintf(fichier,"# iteration n°%d \n",compteur);
			for(k=1;k<ncorps+1;k++){
            x[k]=2.5*k*temps;
			fprintf(fichier,"%d %lf %lf\n",k,temps,x[k]);
 
			}
	      fprintf(fichier,"\n");
		}
	temps+=dt;
	compteur+=1;
 
 
	}while(compteur<=maxcompteur);
	fclose(fichier);
}

et voici le résultat que j'obtiens :

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
 
# iteration n°2 
1 0.000001 0.000002
2 0.000001 0.000005
3 0.000001 0.000007
4 0.000001 0.000010
5 0.000001 0.000012
 
# iteration n°4 
1 0.000003 0.000008
2 0.000003 0.000015
3 0.000003 0.000023
4 0.000003 0.000030
5 0.000003 0.000038
 
# iteration n°6 
1 0.000005 0.000012
2 0.000005 0.000025
3 0.000005 0.000037
4 0.000005 0.000050
5 0.000005 0.000063
 
# iteration n°8 
1 0.000007 0.000017
2 0.000007 0.000035
3 0.000007 0.000052
4 0.000007 0.000070
5 0.000007 0.000087
 
# iteration n°10 
1 0.000009 0.000023
2 0.000009 0.000045
3 0.000009 0.000068
4 0.000009 0.000090
5 0.000009 0.000113

Au lieu d'avoir tout les résultats dans le même fichier tel que montré ci-dessus, j'aimerai écrire dans des fichiers séparés car ( nombre de corps très important). Il faut que j'incrémente le nom de mon fichier comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
 
fichier2.dat
fichier4.dat
fichier6.dat
.
.
.
fichierN.dat
 
N: numéro de l'itération

J'ai déjà écris ce genre de code mais en langage FORTRAN et en langage C je galère à le faire...

Voilà si vous avez une idée, merci à vous et bon week-end.

un truc dans ce genre ?
Code:

1 2 3 4 5 6 7 8 9 int index = 4; /* c'est pour l'exemple */ char filename[1024]; sprintf(filename, "fichier%d.dat", index) fichier = fopen(filename, "w"); if(fichier != NULL) { /* ... ton code */ fclose(fichier); }
Au fait un soupcon de mise en page et d'indentation cohérente rendra ton codse beaucoup plus lisible

17/03/2010, 16h55
mecaplus

Merci pour ta réponse,

Malheureusement ça ne marche pas, j'ai finalement opté pour la solution que j'avais évoquée précédemment, c'est à dire tout écrire dans le même fichier même si cette solution ne me convient pas vraiment.

Merci
17/03/2010, 17h24
Invité(e)

Citation:

Envoyé par mecaplus

Malheureusement ça ne marche pas

Problème de compilation ? d'exécution ?
Tu n'arrives pas à intégrer le code posté par Jenna ?
17/03/2010, 20h04
mecaplus

Effectivement je n'arrive pas à intégrer la partie du code donné par jenna dans mon code ce qui fait que j'ai des erreurs à la compilation, je vais reprendre ça à tête reposée et je vous tiens au courant.
17/03/2010, 20h29
Invité(e)

Citation:

Envoyé par mecaplus

Effectivement je n'arrive pas à intégrer la partie du code donné par jenna dans mon code ce qui fait que j'ai des erreurs à la compilation, je vais reprendre ça à tête reposée et je vous tiens au courant.

Poste ton code

voici mon code que je compte modifier :

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
 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define size 200
//#define ncorps 10
 
 
main ()
{
int k;                       // indice du corps solide
int ncorps;                  // nombre de corps solides dans mon systeme
int compteur;                // le compteur
int maxcompteur;             // nombre max d'itérations
int sauv;                    // fréquence de sauvegarde
double dt,temps;
double x[size]={0};          // la valeur à calculer et à sauvegarder 
                             // pour chaque corps
                             // supposons ici qu'elle est connue
FILE*fichier;      
 
 
dt=0.000001;
temps=0;
ncorps=5;
sauv=2;
maxcompteur=10;
compteur=1;
 
fichier=fopen("resu.dat","w");
 
 
 
 do{
 
		if(compteur%sauv==0){
		    fprintf(fichier,"# iteration n°%d \n",compteur);
			for(k=1;k<ncorps+1;k++){
            x[k]=2.5*k*temps;
			fprintf(fichier,"%d %lf %lf\n",k,temps,x[k]);
 
			}
	      fprintf(fichier,"\n");
		}
	temps+=dt;
	compteur+=1;
 
 
	}while(compteur<=maxcompteur);
	fclose(fichier);
}

qui me génère le résultat suivant dans le fichier resu.dat

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
 
 
# iteration n°2 
1 0.000001 0.000002
2 0.000001 0.000005
3 0.000001 0.000007
4 0.000001 0.000010
5 0.000001 0.000012
 
# iteration n°4 
1 0.000003 0.000008
2 0.000003 0.000015
3 0.000003 0.000023
4 0.000003 0.000030
5 0.000003 0.000038
 
# iteration n°6 
1 0.000005 0.000012
2 0.000005 0.000025
3 0.000005 0.000037
4 0.000005 0.000050
5 0.000005 0.000063
 
# iteration n°8 
1 0.000007 0.000017
2 0.000007 0.000035
3 0.000007 0.000052
4 0.000007 0.000070
5 0.000007 0.000087
 
# iteration n°10 
1 0.000009 0.000023
2 0.000009 0.000045
3 0.000009 0.000068
4 0.000009 0.000090
5 0.000009 0.000113

ok ça marche bien mais j'aurai préféré avoir 5 fichiers du type :

Code:

1
2
3
4
5
6
7
8
 
# resu001.dat
# iteration n°2 
1 0.000001 0.000002
2 0.000001 0.000005
3 0.000001 0.000007
4 0.000001 0.000010
5 0.000001 0.000012

Code:

1
2
3
4
5
6
7
8
 
# resu002.dat
# iteration n°4 
1 0.000003 0.000008
2 0.000003 0.000015
3 0.000003 0.000023
4 0.000003 0.000030
5 0.000003 0.000038

etc...

le nom du fichier est incrémenter à chaque fois que la fréquence de sauvegarde est atteinte.

Je suis entrain d'adapter ce mode a la solution de Jenna sans trop de conviction...

18/03/2010, 09h45
Invité(e)

Citation:

Envoyé par mecaplus

Effectivement je n'arrive pas à intégrer la partie du code donné par jenna dans mon code ce qui fait que j'ai des erreurs à la compilation

Citation:

Envoyé par mecaplus

voici mon code que je compte modifier :
...
Je suis entrain d'adapter ce mode a la solution de Jenna sans trop de conviction...

Poste nous le code tel qui te pose problème : que nous voyons les erreurs de compilation pour t'aider à les corriger.

Voici le code modifier suite à la proposition de Jenna

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
 
 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define size 200
//#define ncorps 10
 
 
main ()
{
int k;                       // indice du corps solide
int ncorps;                  // nombre de corps solides dans mon systeme
int compteur;                // le compteur
int maxcompteur;             // nombre max d'itérations
int sauv;                    // fréquence de sauvegarde
double dt,temps;
double x[size]={0};          // la valeur à calculer et à sauvegarder 
                             // pour chaque corps
                             // supposons ici qu'elle est connue
FILE*fichier;      
char filename[1024]; 
 
dt=0.000001;
temps=0;
ncorps=5;
sauv=2;
maxcompteur=10;
compteur=1;
 
//fichier=fopen("resu.dat","w");
 
 
 
 do{
 
		if(compteur%sauv==0){
		    sprintf(filename,"# fichier%d.dat \n",compteur);
			fichier = fopen(filename, "w");
			if(fichier != NULL)
			{
				for(k=1;k<ncorps+1;k++){
				x[k]=2.5*k*temps;
				fprintf(fichier,"%d %lf %lf\n",k,temps,x[k]);
 
				}
			}
	        //fprintf(fichier,"\n");
		}
	temps+=dt;
	compteur+=1;
 
 
	}while(compteur<=maxcompteur);
	fclose(fichier);
}

Pas de problème à la compilation mais quand je l'exécute, le programme cesse de fonctionner et ferme, je pense qu'il veut écrire dans le fichier mais ne le trouve pas.

Merci pour votre aide et désolé je réfléchissais encore un peu...

Alors, il y a un soucis au niveau du choix du nom de fichier : remplace

Code:

sprintf(filename, "# fichier%d.dat \n", compteur);

par

Code:

sprintf(filename, "fichier%d.dat", compteur);

Après, le fclose n'est pas en regard avec le fopen : il arrive trop tard.
Voici un exemple où il est mieux placé :
J'ai aussi ajouter perror pour avoir une trace du problème si le fichier n'a pas pu être ouvert.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 if (compteur % sauv == 0) { sprintf(filename, "fichier%d.dat", compteur); fichier = fopen(filename, "w"); if (fichier != NULL) { for (k = 1; k < ncorps + 1; k++) { x[k] = 2.5 * k * temps; fprintf(fichier, "%d %lf %lf\n", k, temps, x[k]); } } else { perror(filename); } fclose(fichier); }

merci infiniment, fin du calvaire après 1 mois de recherche.

J'ai réadapté le code. Comme mon compteur peut dépasser le million (il s'agit du nombre d'itérations dans mon cas) je risque d'avoir des noms de fichiers du type fichier2000000.dat, pour éviter ce problème, je définis un deuxième compteur ifichier que j'initialise à 0 et que j'incrémente à chaque fois que ma condition de sauvegarde est vraie et j'ai des fichiers qui ont la forme suivante : fichier001,fichier002, ...fichier010,...fichier100 ect. et c'est ce que je voulais.

Voici le code complet si ça peut servir à d'autres personnes.
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 #include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> #define size 200 #define ncorps 10 main () { int k,compteur,maxcompteur,sauv,ifichier; double dt,temps,x[size]={0}; FILE*fichier; char filename[1024]; dt=0.000001; temps=0; sauv=1; maxcompteur=10; compteur=1; ifichier=0; do{ if (compteur % sauv == 0) {ifichier=ifichier+1; sprintf(filename, "fichier%0.3d.dat",ifichier); fichier = fopen(filename, "w"); if (fichier != NULL) { for (k = 1; k < ncorps + 1; k++) { x[k] = 2.5 * k * temps; fprintf(fichier, "%d %lf %lf\n", k, temps, x[k]); } } else { perror(filename); } fclose(fichier); } temps+=dt; compteur+=1; }while(compteur<=maxcompteur); }
il reste juste à l'intégré dans le code réel. Merci mabu pour ton aide.