Petite explication sur les variables externes

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:

---

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:

---

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

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:

---

1 2 3 4 5 6 7 8 9

double force; int main(void) { ... } // utilisation dans un autre fichier extern double force; int fonction1 () { ... }

---

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:

---

1 2 3

/*Globales.h*/   extern double g_force;

---

Code:

---

1 2 3 4

/*Globales.c*/ #include "Globales.h"   double g_force = 0.0;

---

Code:

---

1 2 3 4 5 6

/*Main.c*/ #include "Globales.h"   int main(void) { ... }

---

Code:

---

1 2 3 4

/*AutreFichier.c*/ #include "Globales.h"   ...

---

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:

---

double g_force = 0.0 ;

---

Pourquoi indiquer à nouveau le double ?

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.

J'y arrive pas :oops: !

J'ai ces trois fichiers :

main..h

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

---

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:

---

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:

---

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 ?

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:

---

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

---

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

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

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.

Citation:

---

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 ?

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:

---

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:

---

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

Petite correction.

Citation:

---

Envoyé par diogene

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