Discussion :

[Ladgalen]

Bonjour

Supposons que j'ai un programme avec chaque fonction et le main dans un fichier source différent.

Dans le fichier main.c je déclare une variable comme ceci :

Code :

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

1
2
3
4
5
6
7
 
...
extern double force;
 
int main(void) {
 ...
}

Est ce que du coup je peux utiliser force dans n'importe qu'elle fonction de mon programme ? ou faut - il que je la redéclare dans chaque fichier ou j'utilise force :

Code :

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

1
2
3
4
5
6
7
 
...
extern double force;
...
int fonction1 () {
...
}

Mon but étant par exemple de déclarer force au départ, si c'est un tableau de l'allouer un peu plus tard, puis qu'une fonction les calcules une autres les utilises une autre les modifies ect ... toutes ces fonctions utilisant la MEME variables (et zone mémoire).

Il me semble que le fait de mettre extern joue se role mais dans un programme en c que j'ai un peu parcouru, tout un tas de variables globales sont définies (avec extern) dans un main.h qui est inclu dans presque toutes les fonctions. D'où ma question !

Pour ceux qui connaissent je voudrais retrouver le même type d'utilisation de variables globales d'un programme qui sont défini en fortran dans un common ou un module. Mais dans ce cas on fait appel au common ou au module dans chaque sous programme.

Merci pour votre aide

[diogene]

Dans un fichier .c, tu définies ta variable globale comme d'habitude.
Dans les fichiers qui ont besoin d'utiliser cette variable, tu la déclares avec le qualificatif extern et rigoureusement de la même façon que lors de la définition. Le but est de dire à cette unité de compilation que cette variable est de tel type et existe quelque part. Cette déclaration peut figurer dans un .h sans problème puisqu'elle n'entraine pas de création de variables.

Donc, avec ton exemple :

Code :

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

1
2
3
4
5
6
7
8
9
double force; 
int main(void) {
 ...
}
// utilisation dans un autre fichier
extern double force;
int fonction1 () {
...
}

[Médinoc]

Tu dois la redéclarer dans chaque unité de compilation (pour ça, on a tendance à mettre la déclaration dans un fichier d'en-tête .h) et la définir vraiment dans une seule unité de compilation. Exemple:

Code C :

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

1
2
3
/*Globales.h*/
 
extern double g_force;

Code C :

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

1
2
3
4
/*Globales.c*/
#include "Globales.h"
 
double g_force = 0.0;

Code C :

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

1
2
3
4
5
6
/*Main.c*/
#include "Globales.h"
 
int main(void) {
 ...
}

Code C :

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

1
2
3
4
/*AutreFichier.c*/
#include "Globales.h"
 
...

[Ladgalen]

Merci pour vos réponses, je vais donc les déclarer dans mon .h !

Est ce qu'il est nécessaire de repréciser

Code :

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

double g_force = 0.0 ;

Pourquoi indiquer à nouveau le double ?

[Médinoc]

Parce que c'est une définition (ici avec initialisation, mais je ne sais plus si c'est vraiment nécessaire), pas une simple affectation.

[Ladgalen]

J'y arrive pas !

J'ai ces trois fichiers :

main..h

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
 
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
/* thermo */
extern	int	nat ;
extern	double	volume ;
extern	double	temperature ;
extern	double 	xi ;
extern	double	pression ;
 
/* atome */
extern	double	masse ;
extern	double	LJsigma ;
extern	double	LJeps ;
extern	char 	*aname ;
 
/* constantes physiques ou mathematiques */
extern	double	boltzman ;
extern	double	avogadro ;
extern	double	qElectron ;
extern	double	aBohr ;
extern	double	pi ;

Mon fichier main.c

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
 
#include "main.h"
 
extern int initialisation( void );
 
int main( int narg, char *arg[] ) {
 
	int 	erreur = 0 ;
	int 	i ;
 
	// Initialisation des constantes et ouverture fichiers de sorties
	erreur += initialisation();
 
	printf ( "erreur  : %d \n", erreur );
 
	printf ("temperature	: %e \n", temperature );
	printf ("LJsigma	: %e \n", LJsigma );
	printf ("LJeps  	: %e \n", LJeps );
 
	return erreur;
}

et le fichier initialisation.c

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
 
#include "main.h"
 
int initialisation(void) {
 
	int	erreur;
 
	double	boltzman  	= 1.380662e-23 ;  	// J.K-1
	double	avogadro 	= 6.0228e23 ;		// mol-1
	double	qElectron 	= 1.6021892e-19 ;	// C
	double	aBohr 		= 0.5291e-10 ;		// m
	double	pi 		= 4. * atan(1.) ;	
 
	double temperature 	= 300.e0 ;
 
	char 	*aname		= "Ar" ;
	double 	masse		= 39.95e-3 / avogadro ;
	double	LJsigma		= 3.405e-10 ;
	double	LJeps		= 1.6567944e-21 ;
 
	erreur = 0;
 
	return erreur;
 
}

et j'ai le message d'erreur suivant :

Code :

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

1
2
3
4
5
6
 
/tmp/ccD5P3Wj.o: In function `main':
simLad.c:(.text+0x35): undefined reference to `temperature'
simLad.c:(.text+0x4b): undefined reference to `LJsigma'
simLad.c:(.text+0x61): undefined reference to `LJeps'
collect2: ld a retourné 1 code d'état d'exécution

Pourquoi il ne trouve pas les variables vu qu'elles sont dans le main.h ? Peut être que ce n'est pas du tout la bonne façon de faire en C ! Dites moi ?

[Médinoc]

Tes définitions de variables sont dans une fonction, elles ne touchent donc pas les variables globales: Ce sont seulement des variables locales du même nom.

Essaie ainsi:

Code C :

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
/*Initialisation.c*/
#include "main.h"
 
double	boltzman  	= 1.380662e-23 ;  	// J.K-1
double	avogadro 	= 6.0228e23 ;		// mol-1
double	qElectron 	= 1.6021892e-19 ;	// C
double	aBohr 		= 0.5291e-10 ;		// m
double	pi;
 
double temperature 	= 300.e0 ;
 
char 	*aname		= "Ar" ; /*devrait être char const * */
double 	masse;
double	LJsigma		= 3.405e-10 ;
double	LJeps		= 1.6567944e-21 ;
 
int initialisation(void) {
 
	int	erreur;
 
	pi 		= 4. * atan(1.) ;	
 	masse		= 39.95e-3 / avogadro ;
 
	erreur = 0;
 
	return erreur;
 
}

[Ladgalen]

oui pour le coup des variables locale j'aurai pu voir ça tout seul ...

Mais il n'existe aucun moyen de ne déclarer ces variables externes qu'une seule fois car sinon ça perd de son intéret. Avec ce que tu me propose, il faut que je les déclare à chaque fois que je met mon main.h dans une fonction qui les utilise (ce qui est probablement l'origine de l'erreur que j'ai dans le main.c).

[diogene]

La variable g_force n'est définie (créée) qu'une fois : lorsque tu as écrit double g_force = 0.0 ;
Les extern double g_force ; ne crée pas une autre variable g_force, ils déclarent simplement qu'il existe quelque part ailleurs dans le programme une variable de type double et qui s'appelle g_force et que lorsque tu utilises g_force, il s'agit de cette variable.

Avec ce que tu me propose, il faut que je les déclare à chaque fois que je met mon main.h dans une fonction qui les utilise (ce qui est probablement l'origine de l'erreur que j'ai dans le main.c).

Evidemment, à chaque fois que tu utilises g_force, il faut qu'elle soit définie par un extern double g_force (c'est naturellement inutile là où elle est définie), sinon comment le compilateur peut-il deviner ce que c'est ?

[Ladgalen]

Je viens de comprendre.

Si j'ai une variable globale, il faut que dans toutes mes fonctions elles soit déclarée en dehors de la fonction comme ceci :

Code :

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

1
2
 
extern double globale;

sauf dans une des fonction du programme ou elle est déclaré en dehors de cette fonction de cette manière :

Code :

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

1
2
 
double globale;

En faisant ça ça marche. Ce que j'avais pas compris c'est que par rapport à ce qu'à écrit Médinoc je pensais que dans toutes les fonctions, il fallait déclarer les variables globales avec et sans le extern ... je trouvais ça louche !

Merci à vous tous

[Médinoc]

Petite correction.

Evidemment, à chaque fois que tu utilises g_force, il faut qu'elle soit déclarée par un extern double g_force (c'est naturellement inutile là où elle est définie), sinon comment le compilateur peut-il deviner ce que c'est ?

Aussi, il me semble avoir lu que la déclarer extern avant de la définir était obligatoire en C++.