Discussion :

[mecaplus]

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 :

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

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

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

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.

[Jenna]

un truc dans ce genre ?

Code :

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

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

[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

[Invité(e)]

Malheureusement ça ne marche pas

Problème de compilation ? d'exécution ?
Tu n'arrives pas à intégrer le code posté par Jenna ?

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

[Invité(e)]

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

[mecaplus]

voici mon code que je compte modifier :

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

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

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

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 :

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

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

[Invité(e)]

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

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.

[mecaplus]

Voici le code modifier suite à la proposition de Jenna

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

[Invité(e)]

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

Code :

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

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

par

Code :

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

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 :

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

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

[mecaplus]

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 :

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