Recuperer une variable d'un autre fichier

Version imprimable

Le principe de mon programme est de creer un fichier a partir d'une ligne de commande et d'y stocker des lignes d'arguments (a interpreter apres).

Je possede deux fichier create.c et add.c

Exemple sur le terminal Unix:
Code:

1 2 UNIX> create fichier.c // creara un nouveau fichier UNIX> add qqchose //cette ligne devra se stocker dans le fichier precedent (fichier.c dans ce cas)
create.c
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 #include "header.h" static char fname[31]; static char fname2[31]; void createfile(char file[]){ FILE *new; new = fopen(file, "w"); printf("\nFile \"%s\" created.\n\n", file); } int main ( int argc, char * argv [ ] ) { char *p; p = ( char* ) strcmp(argv[0], "create"); if ( argc == 1 && p == 0 ){ printf ( "Please, specify a filename: " ); gets(fname); createfile(fname); } if ( argc == 2 ){ createfile(argv[1]); } return 0; }
add.c encore vide.

Ma question

comment appeller au fichier add.c la variable qui s'occupe du nom de fichier dans create.c ?

J'ai commence avec des variables statiques, mais il doit y avoir une procedure que je ne connais pas encore...

27/10/2007, 09h49
Médinoc

Tu ne peux.

Ce que tu PEUX faire, c'est stocker dans un fichier temporaire le nom du fichier que tu crées. Mais il faudra donc le réouvrir à chaque fois dans le programme add...

Citation:
Envoyé par virtuadrack
Le principe de mon programme est de creer un fichier a partir d'une ligne de commande et d'y stocker des lignes d'arguments (a interpreter apres).

Je possede deux fichier create.c et add.c

Exemple sur le terminal Unix:
Code:

1 2 UNIX> create fichier.c // creara un nouveau fichier UNIX> add qqchose //cette ligne devra se stocker dans le fichier precedent (fichier.c dans ce cas)
create.c
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 #include "header.h" static char fname[31]; static char fname2[31]; void createfile(char file[]){ FILE *new; new = fopen(file, "w"); printf("\nFile \"%s\" created.\n\n", file); } int main ( int argc, char * argv [ ] ) { char *p; p = ( char* ) strcmp(argv[0], "create"); if ( argc == 1 && p == 0 ){ printf ( "Please, specify a filename: " ); gets(fname); createfile(fname); } if ( argc == 2 ){ createfile(argv[1]); } return 0; }
add.c encore vide.

Ma question

comment appeller au fichier add.c la variable qui s'occupe du nom de fichier dans create.c ?
Si "add" et "create" sont des programmes indépendants, alors tu entres dans le domaine de la communication inter-processus qui peut se résoudre par le biais de

pipes
sockets
ipcs (msq)
ou de façon plus "primaire" par l'intermédiaire de fichiers destinés à stocker les valeurs que tu veux faire transiter entre les deux programmes (comme l'a dit Médinoc) ou par tout autre outil informatique destiné à conserver l'information pour que n'importe qui puisse la récupérer (comme les bases de données par exemple).

Si "add" et "create" sont deux fonctions destinées à appartenir au même programme, alors les deux fonctions peuvent s'appeler l'une l'autre et se transmettre des valeurs (dont le nom de fichier)

PS: Pourquoi tu convertis la valeur renvoyée par "strcmp()" en pointeur ???

Citation:

Envoyé par virtuadrack

J'ai commence avec des variables statiques, mais il doit y avoir une procedure que je ne connais pas encore...

La notion de "variable statique" ne s'applique qu'au programme dans lequel la variable se trouve. Cela indique au programme que la variable doit garder son intégrité durant tout le temps que le programme fonctionne (donc
si une fonction contenant une statique est appelée plusieurs fois, à chaque appel tu pourras accéder à la valeur de la variable telle qu'elle était lors de l'appel précédent)

Merci pour l'astuce. J'ai reussi a recuperer le nom de la variable dans mon fichier add.c.

Maintenant je n'arrive pas a y ecrire quelquechose, voila mes codes.

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
/* ici tout se fait comme prevu */
 
#include "header.h"
 
void createfile(char file[]){
  FILE *new;
  new = fopen(file, "w");
  printf("\nFile \"%s\" created.\n\n", file);
}
 
/* fonction pour creer le fichier temporaire */
 
void fnamefile(char varfile[]){
  FILE *tf;
  tf = fopen("tempfile", "w");
  fprintf(tf, "%s\n", varfile);
}
 
int main ( int argc, char * argv [ ] )
{
  if ( argc == 1 ){
       printf ( "\nPlease, specify a filename: " );
       gets(fname);
       createfile(fname);
       fnamefile(fname);
       }
 
  if ( argc == 2 ){
      createfile(argv[1]);
      fnamefile(argv[1]);
      }
 
  return 0;
}

add.c

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
#include "header.h"
 
int main(char argc, char *argv[]){
 
FILE *fp, *sf;
char scriptc [30];
 
 if ((fp = fopen("tempfile","r")) == NULL) {
    printf("\nCannot add since no script file was created.");
    printf("\nTo create a script use: create [scriptname]\n\n");
    exit(1);
    }
 
 if ((fp = fopen("tempfile","r")) != NULL) {
    fgets(scriptc, 31, fp);
    printf("\nscriptfile: %s", scriptc);  // le nom du fichier creer s'affiche correctement
 
    sf = fopen(scriptc, "w");  // supposee ouvrir le fichier cree et y ecrire
    fprintf(sf, "add %s", argv[1]);          // "add" + le 2 eme argument
    }
 
 
return 0;
   }

Je n'ai pas d'erreurs de compilations, mais le fichier cree ne contient rien 8O

Code:

1 2 3 4 5 6 7 if ((fp = fopen("tempfile","r")) == NULL) { printf("\nCannot add since no script file was created."); printf("\nTo create a script use: create [scriptname]\n\n"); exit(1); } if ((fp = fopen("tempfile","r")) != NULL) {
Ici tu fait déja une erreur en écrasant le pointeur fp.
Il vaut mieux faire:
Code:

1 2 3 4 5 6 7 if ((fp = fopen("tempfile","r")) == NULL) { printf("\nCannot add since no script file was created."); printf("\nTo create a script use: create [scriptname]\n\n"); exit(1); } else {
Mais le fait que tu n'écris pas dans ton fichier ne provient pas de là.
Code:

1 2 sf = fopen(scriptc, "w");
Ici il faut que tu testes la valeur de retour de fopen.

Ensuite ton code ne contient aucun fclose et tu oublies de tester que tu as bien un argument.

Je n'ai pas regardé le code de creer.c mais essaye déja de corriger ces erreurs dans add.c

Citation:
Envoyé par virtuadrack
Code:

1 2 3 4 5 6 7 8 9 /* ici tout se fait comme prevu */ #include "header.h" void createfile(char file[]){ FILE *new; new = fopen(file, "w"); printf("\nFile \"%s\" created.\n\n", file); }
Danger => tu ouvres un fichier sans le fermer => tu alloues un descripteur que tu perds ensuite...

Voici tes sources avec quelques corrections et commentaires.
Ça compile, mais je n'ai pas pu tester.

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
/* Med: Je n'ai pas header.h, donc je mets les includes standard.
#include "header.h"*/
#include <stdio.h>
#include <string.h>
 
/* Med: Utiliser un nom plus explicite pour le paramètre.
Et utiliser const, puisqu'on ne modifie pas le nom de fichier. */
void createfile(char const *fileName) {
	FILE *newFile;
	newFile = fopen(fileName, "w");
 
	/* Med: Il faut tester si ça a réussi ou non. */
	if(newFile != NULL) {
		printf("\nFile \"%s\" created.\n\n", fileName);
		/* Med: Tu avais oublié le fclose() */
		fclose(newFile);
	}	
}
 
/* fonction pour creer le fichier temporaire */
/* Med: Noms plus explicites pour fonctions et variables*/
void savefilename(char const *fileNameToSave) {
	FILE *tf;
	tf = fopen("tempfile", "w");
	/* Med: On teste... */
	if(tf != NULL) {
		fprintf(tf, "%s\n", fileNameToSave);
		fclose(tf);
	}
}
 
/* Med: fonction fclean() du forum, retourne -1 si EOF. */
int fpurge(FILE *in) {
	int c;
	while((c=fgetc(in))!='\n' && c!=EOF) {
	}
	if(c==EOF)
		return -1;
	return 0;
}
int fclean(char *str, FILE *in) {
	char *pLF = NULL;
	int ret = 0;
	if(str!=NULL) {
		pLF = strchr(str, '\n');
	}
	if(pLF!=NULL) {
		/* Le \n est dans la chaîne, il n'est donc plus dans le flux.
		On le supprime de la chaîne en la tronquant. */
		*pLF = '\0';
	} else {
		/* Le \n n'est pas dans la chaîne, ou il n'y a pas de chaîne.
		Il est donc encore dans le flux, il faut donc le purger. */
		ret = fpurge(in);
	}
	return ret;
}
 
int main ( int argc, char * argv [ ] )
{
	/* Med: La variable fname doit être déclarée dans la fonction: Elle n'a aucune raison d'être globale */
	if ( argc == 1 ) {
		char fname[30];
		printf ( "\nPlease, specify a filename: " );
		/* Med: Ne pas utiliser gets() : Utiliser fgets() et la fonction fclean() du forum */
		fgets(fname, sizeof fname, stdin);
		fclean(fname, stdin);
		createfile(fname);
		savefilename(fname);
	}
 
	if ( argc == 2 ) {
		createfile(argv[1]);
		savefilename(argv[1]);
	}
 
	return 0;
}

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
/* Med: Je n'ai pas header.h, donc je mets les includes standard.
#include "header.h"*/
#include <stdio.h>
#include <string.h>
 
/* Med: fonction fclean() du forum, retourne -1 si EOF. */
int fpurge(FILE *in) {
	int c;
	while((c=fgetc(in))!='\n' && c!=EOF) {
	}
	if(c==EOF)
		return -1;
	return 0;
}
int fclean(char *str, FILE *in) {
	char *pLF = NULL;
	int ret = 0;
	if(str!=NULL) {
		pLF = strchr(str, '\n');
	}
	if(pLF!=NULL) {
		/* Le \n est dans la chaîne, il n'est donc plus dans le flux.
		On le supprime de la chaîne en la tronquant. */
		*pLF = '\0';
	} else {
		/* Le \n n'est pas dans la chaîne, ou il n'y a pas de chaîne.
		Il est donc encore dans le flux, il faut donc le purger. */
		ret = fpurge(in);
	}
	return ret;
}
 
 
/* Med: Faire une fonction pour récupérer le nom de fichier.
Retourne -1 si erreur */
int loadfilename(char *fname, int size) {
	int ret = -1;
	FILE *tf;
	tf = fopen("tempfile", "r");
	/* Med: On teste... */
	if(tf != NULL) {
		char *resFgets = fgets(fname, size, tf);
		/* Med: On teste aussi le résultat de fgets()... */
		if( resFgets!=NULL && strchr(fname, '\n')!=NULL ) {
			ret = 0;
		}
		fclean(fname, tf);
		fclose(tf);
	}
	return ret;
}
 
int main(char argc, char *argv[]) {
 
	FILE *sf;
	char scriptc [30];
 
	if(loadfilename(scriptc, sizeof scriptc) < 0) {
		printf("\nCannot add since no script file was created.");
		printf("\nTo create a script use: create [scriptname]\n\n");
		/* Med: Pourquoi appeler exit() alors qu'un simple return du main() suffit? */
		return 1;
	}
 
	printf("\nscriptfile: %s", scriptc);  // le nom du fichier creer s'affiche correctement
 
	/* Med: Ouvrir le fichier en mode "append" ("a") */
	sf = fopen(scriptc, "a");  // supposee ouvrir le fichier cree et y ecrire
	if(sf != NULL) {
		fprintf(sf, "add %s", argv[1]);          // "add" + le 2 eme argument
	}
 
 
	return 0;
}

Voici ma version à moi qui s'utilise comme suit:

Code:

thierry@mujigka:~$ ./create fichier-test | ./add "Bienvenu sur developpez!"

Je n'utilise pas de fichier temportaire et les deux programmes s'utilisent ensemble avec un pipe.

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
/* create.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "fclean.h"
 
#define FNAME_MAXLEN 64
 
int createfile(char const file[]);
 
int main(int argc, char *argv[])
{
    int err = 0;
    int ret = EXIT_SUCCESS;
    /* -tc- fname n'est pas definie dans ton programme, ou alors en 
       global dans ton fichier "header.h" (nom tres mal choisi pour
       un fichier d'en-tete) */
    char fname[FNAME_MAXLEN + 2] = "";
 
    if (argc == 1)
    {
        printf("Please, specify a filename: ");
        /* -tc- Il est necessaire de forcer l'affichage de l'invite */
        fflush(stdout);
        /* -tc- Il est fortement deconseille d'utilise gets(). Utilise fgets()
           a la place. */
        fgets(fname, sizeof fname, stdin);
        /* -tc- apres chaque utilisation de fgets(), on fait le menage: 
           rechercher plus d'info sur fclean() sur ce forum! */
        fclean(fname, stdin);
    }
    else                        /* -tc- argc >= 2 */
    {
        strncat(fname, argv[1], sizeof fname - 1);
    }
 
    err = createfile(fname);
    if (err == 0)
    {
        fprintf(stdout, "%s created!\n", fname);
        fflush(stdout);
    }
    else
    {
        /* -tc- la creation du fichier a echoue */
        ret = EXIT_FAILURE;
    }
 
    return ret;
}
 
int createfile(char const file[])
{
    int err = 0;
 
    if (file != NULL)
    {
        FILE *new = NULL;
        new = fopen(file, "w");
        /* -tc- on retourne un code d'erreur si la creation du fichier a 
           echoue */ 
        if (new == NULL)
        {
            fprintf(stderr, "Impossible to create file \"%s\"!\n", file);
            err = 1;
        }
    }
 
    return err;
}

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
/* add.c */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "fclean.h"
 
#define SCRIPTC_MAXLEN 64
 
void usage(void);
 
int main(int argc, char *argv[])
{
    char const *p_textToAdd = NULL;
    char scriptc[SCRIPTC_MAXLEN + 1] = "";
    int ret = EXIT_SUCCESS;
    int err = 0;
 
    if (argc == 1)
    {
        usage();
        err = 2;
    }
    else if (argc == 2)
    {
        /* -tc- tampon destine a la saisie du nom du fichier sur le flux 
           d'entree standard */
        char buffer[SCRIPTC_MAXLEN + 2] = "";
 
        p_textToAdd = argv[1];
        /* -tc- on recupere le nom du fichier depuis le flux d'entree
           standard */
        if (fgets(buffer, sizeof buffer, stdin) != NULL)
        {
            err = fclean(buffer, stdin);
            fprintf(stderr, "DEBUG: %s\n", buffer);
            if (err == 0)
            {
                /* -tc- on recupere le 1er mot saisi sur le flux d'entree 
                   standard */
                sscanf(buffer, " %s", scriptc);
            }
        }
        else
        {
            /* -tc- EOF ou erreur inconnue */
            err = 2;
        }
 
    }
    else                        /* -tc- argc > 2 */
    {
        p_textToAdd = argv[2];
        strncat(scriptc, argv[1], sizeof scriptc - 1);
    }
 
    if (err == 0)
    {
        FILE *fp = fopen(scriptc, "a");
        if (fp != NULL)
        {
            fprintf(fp, "%s\n", p_textToAdd);
 
            fclose(fp), fp = NULL;
        }
        else
        {
            fprintf(stderr, "Impossible to open file \"%s\"!\n", scriptc);
            ret = EXIT_FAILURE;
        }
    }
    else if (err == 1)
    {
        fprintf(stderr, "File name is too long (max. %d characters)!\n",
                SCRIPTC_MAXLEN);
        ret = EXIT_FAILURE;
    }
    else
    {
        usage();
        ret = EXIT_FAILURE;
    }
 
    return ret;
}
 
void usage(void)
{
    fprintf(stderr, "add [FileName] \"TextToAdd\"\n");
}

Il faut encore les fichiers fclean.h et fclean.c:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* fclean.h */
 
#ifndef H_TC_FCLEAN_20071029090859
 
#include <stdio.h>
 
/*
 * Elimine le caractere de fin de ligne saisi par fgets() et nettoie le tampon 
 * du flux entrant si la saisie a ete tronquee. Retourne un code d'erreur 
 * valant 1 si la ligne saisie par fgets() a ete tronquee, 0 sinon.
 */
int fclean(char *buffer, FILE * fp);
 
 
#define H_TC_FCLEAN_20071029090859
#endif /* guard #ifndef H_TC_FCLEAN_20071029090859 */

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
/* fclean.c */
 
#include <stdlib.h>
#include <string.h>
#include "fclean.h"
 
int fclean(char *buffer, FILE * fp)
{
    int err = 0;
 
    if (fp != NULL)
    {
        char *pc = strchr(buffer, '\n');
 
        if (pc != NULL)
        {
            /* La presence du caractere de fin de ligne indique que la
               saisie n'a pas ete tronquee */
            *pc = 0;
        }
        else
        {
            /* le caractere de fin de ligne n'a pas ete trouve (saisie 
               tronquee): on purge le tampon du flux entrant */
            int c;
 
            while ((c = fgetc(fp)) != '\n' && c != EOF)
            {
            }
 
            err = 1;
        }
    }
 
    return err;
}

Thierry