voilà je suis en train d'écrire un programme en C et j'aimerais définir une variable qui soit présente et qui ait la meme valeur dans toutes les fonctions, main et sous programme

comment faire ?

merci d'avance

la passer par référence à toutes tes fonctions
 
ou bosser comme un goret, la coller dans une zone mémoire figée, et taper à la main à cette adresse depuis partout dans ton programme

ya pas un moyen plus simple que ça ?
 

chais pas, je sais pas faire de C

Voire eventuellement extern pour la compilation séparée.
Mais le pointeur est la solution la plus élégante.

ah oui c'est vrai qu'en C on parle pas de référence, mais de pointeur plutôt

+1 pour le pointeur, c'est très mauvais les variables globales....

ben si elle est globale mais constante ?

.h
extern const int foo;
 
.c
#include .h
const int foo = 3;

déjà, si elle est constante, on ne parle plus de variable...
 
ensuite, le risque des variables globales, c'est qu'elles soient écrasées par le scope local. je ne sais pas ce que fait le C dans ce cas. toujours est-il que c'est risqué et pas propre, parce qu'un dev qui passe derrière est rapidement induit en erreur par la valeur globale.

Il gère parfaitement la situation. Toute nouvelle définition d'une variable masque la précédente dans le bloc dans lequel elle est définie. Dès qu'on quitte le bloc, on a de nouveau accès à la variable précédente.
 
Le mot clef "extern" peut être utilisé chaque fois qu'on veut faire référence à la globale
 

 
Une des solutions pour utiliser des variables globales tout en "essayant" de rester propre est de redéclarer la variable avec "extern" dans chaque fonction où elle est utilisée => au-moins, si la variable est perdue (écrasée) par accident, on peut "facilement" (entre guillemets) cibler les fonctions qui sont suceptibles d'avoir écrasée la globale...
 
Ex:

Justement, en C# par exemple, c'est interdit de faire ça, tout comme en Java je crois.
 
Parceque si effectivement, ça peut s'avérer utile dans certains cas, c'est très dangereux notamment pour la maintenance.
 

int main()
{
    /* bla bla sur 500 lignes */
    int nbColonnes = 4;
    /* bla bla sur 500 lignes */
    {
         /* bla bla sur 500 lignes */
         j'utilise nbColonnes
         /* bla bla sur 500 lignes */
         int nbColonnes = 12;
         /* bla bla sur 500 lignes */
         j'utilise nbColonnes
         /* bla bla sur 500 lignes */
    }
    /* bla bla sur 500 lignes */
    j'utilise nbColonnes
    /* bla bla sur 500 lignes */
}

 
=> Ce cas, si le dev qui doit modifier le code ne dispose pas d'un super environnement permettant d'atteindre la définition des variables, il y a de grandes chances pour qu'il ne retienne pas la bonne valeur lors de sa modification. Ainsi, il va introduire un bug, qu'il va avoir un mal de chien à corriger, car la raison très loin d'être évidente.
 
 
Anyway, dans le Whitepaper "How to design unmaintainable code" ils recommandent l'utilisation des variables globales, on peut donc en déduire rapidement que c'est à éviter comme la peste
Le C++ et le C sont d'ailleurs lourdement montrés du doigt par ce document, indiquant dès l'introduction que ce sont des langages de prédilection pour faire du code impossible à relire
ADA par contre, est fortement déconseillé par ce document, car il empêche près de 95% des méthodes obfuscation Vive ADA !

 
( et au fait, on ne fait pas des fonction de 4klignes directement dans le main )

bin en fait, c'est pas vraiment une variable, c'est plutot un paramètre
 
ca changera pas pendant une execution du programme
 
mais je voudrais lancer le programme pour plusieurs valeurs de ce paramètre

Bon, on va pas comparer les langages. Parce que sinon, moi je cite "Python" où toute fonction a automatiquement accès à toutes les variables du programme principal... mais en lecture par défaut (si on veut l'écriture faut l'expliciter)
 

int main()
{
    /* bla bla sur 500 lignes */
    int nbColonnes = 4;
    /* bla bla sur 500 lignes */
    {
         /* bla bla sur 500 lignes */
         j'utilise nbColonnes
         /* bla bla sur 500 lignes */
         int nbColonnes = 12;
         /* bla bla sur 500 lignes */
         j'utilise nbColonnes
         /* bla bla sur 500 lignes */
    }
    /* bla bla sur 500 lignes */
    j'utilise nbColonnes
    /* bla bla sur 500 lignes */
}

Evidemment. Ce n'est pas parce que l'écriture d'une énormité est autorisée qu'il faut absolument l'écrire. S'amuser à redéfinir des variables dans des sous-blocs c'est très dangereux. Possible... mais dangereux !!!
 

Boaf... dans tout langage il y a une façon saine d'écrire du code... et il y a 999.999 autres façons d'écrire porc...
 

Vive Python !!!    

t'as aussi le droit d'avoir un compilateur pas quiche qui va te dire les ambiguités.

 
Non, sans rire, le C a été conçu dans l'optique "le programmeur sait ce qu'il fait". Maintenant, on se met à écrire des compilos pour nous avertir que, peut-être, on ne sait pas ce qu'on fait. Il n'y a pas quelque part une certaine incohérence ???

 
J'aurais dis plutôt dans l'optique "bon on a pas encore ni les outils ni la puissance pour savoir à la place du programmeur ce qu'il fait et on aimerait éviter que les  les compils durent trois plombes, on verra plus tard..."

euh je vois pas le rapport. Le C précise l'ordre de résolution. -Wshadow avertit quand il y a masquage.

Ben normallement, il ne devrait jamais avoir besoin de cette option car quand tu crées ta locale

• soit tu décides de masquer la globale en toute connaissance de cause parce que tu n'en as pas besoin
• soit tu ignores qu'il y a une globale qui porte ce nom ce qui prouve que, pour la zone dans laquelle tu programmes, tu n'as là non-plus pas besoin de la globale
• soit tu as besoin aussi de la globale et tu t'apercevras très vite tout seul du soucis => là t'auras certes quelques modifs à faire mais est-vraiment bien contraignant ? Surtout qu'en général, certains conseils de prog préconisent de particulariser les globales pour bien les repérer (par un préfixe "g" par exemple...)

Dans le pire des cas, tu est au sein d'un bloc qui masque, mais trop loin de la déclaration pour le voir, et tu compte utiliser la globale. Ça ne devrait cependant pas arriver si tu évites de faire des fonctions de 4km de long. (et sinon y'a ton point n°3 pour te sauver la vie).

 
#include <stdio.h>
 
Combien de déclaration de variables globales importes-tu ? Peux tu me les citer de tête avec leur type ?

La politique de l'autruche a fait ses preuves.

Dans mon monde, le problème des bugs, c'est justement qu'on ne s'en aperçoit pas de prime abord. Si mon outil peut m'aider à la prévenir, je l'utilise.

Ouaip... tu m'as convaincu. C'est vrai que je ne connais pas l'ensemble des globales de "stdio.h". Après-tout, on t'a offert un outil, autant l'utiliser. D'ailleurs, je me demande si je ne l'utilise pas moi aussi sans le savoir (comme M. Jourdain). L'option "-Wall" implique-t-elle de facto "-Wshadow" ???

Non http://gcc.gnu.org/onlinedocs/gcc- [...] ng-Options

"all" ça veut pas dire "tous" ?
 
t'ain le C c'est trop fort

 
Tu es dev sur gcc, tu "invente" un nouveau warning et tu release la nouvelle version, les gens mettent à jour et certains utilisaient -Wall , est-ce une bonne idée de leur faire voir apparaitre de nouvelles choses inopinément (ou pire, de casser la compil si ils utilisaient -Werror), le tout pour un warning pas utile à tout le monde que la norme ne demande pas d'afficher ?

à ce moment, tu crées un nouveau flag, et tu n'utilises pas -Wshadow mais -WXshadow (avec X pour "eXtra" )
 
ça s'appelle de la rigueur.

Rien à voir avec le C. C'est un problème avec les options d'un certain compilateur. (gcc). -Wall avait un sens à un certain moment du développement de ce compilateur, puis, ceui-ci ayant évolué, d'autres 'flags' (options) sont apparues. On les a alors regroupées sous le nom de -W, puis -Wextra...

Ca peut encore évoluer. Ce qui est bien avec gcc, c'est que ça bouge... (on est est à la version 4.3)

 
-Wall est en constante évolution ; en raisons de nouveau warning qui a un instant t, sont jugés bénéfiques à un utilisateur moyen, en raisons de warnings qui, progressivement, perdent toutes raisons d'être diagnostiqués, etc.
 

ça, tout les utilisateurs de GCC savent bien que c'est difficilement utilisable lorsqu'on est amené à utiliser plusieurs versions de GCC.
 
 

Je crois que l'objectif est de lui faire conserver son sens initial.
 

Côtés Warning, c'est assez actif. Il devrait y avoir pas mal d'améliorations pour 4.3 -- on en est pas encore là, 4.2 a déjà bien du mal à voir le jour.

pour en revenir au sujet d'origine et pour répondre a l'auteur : utilise une variable globale !!
 
Il faut etre taré pour passer cette variable comme argument dans toutes les fonctions, d'autant plus que niveau maintenance du code c'est bien merdique quand meme.... alors OUI les variables globales sont a éviter généralement, mais c'est pas une raison pour les éviter a tous prix et dans le cas présent c'est plus que nécessaire...