Variable globale

En programmation informatique , une variable globale est une variable à portée globale , ce qui signifie qu'elle est visible (donc accessible) dans tout le programme, à moins d' être masquée . L'ensemble de toutes les variables globales est appelé environnement global ou état global. Dans les langages compilés , les variables globales sont généralement des variables statiques , dont l'étendue (durée de vie) correspond à la durée d'exécution totale du programme, bien que dans les langages interprétés (y compris les interpréteurs de ligne de commande ), les variables globales soient généralement allouées dynamiquement lors de leur déclaration, car elles ne sont pas connues à l'avance.

Dans certains langages, toutes les variables sont globales, ou globales par défaut, alors que dans la plupart des langages modernes, les variables ont une portée limitée, généralement une portée lexicale , bien que les variables globales soient souvent disponibles en déclarant une variable au niveau supérieur du programme. Dans d'autres langages, cependant, les variables globales n'existent pas ; il s'agit généralement de langages de programmation modulaires qui imposent une structure de module, ou de langages de programmation orientés objet basés sur des classes qui imposent une structure de classe.

Les mécanismes d'interaction avec des variables globales sont appelés mécanismes d'environnement global (voir aussi état global ). Le paradigme de l'environnement global est contrasté avec le paradigme de l'environnement local, où toutes les variables sont locales sans mémoire partagée (et donc toutes les interactions peuvent être reconduites pour le passage de messages ).

Les variables globales sont largement utilisées pour transmettre des informations entre des sections de code qui ne partagent pas de relation appelant/appelé, comme les threads simultanés et les gestionnaires de signaux. Les langages (y compris C) où chaque fichier définit un espace de noms implicite éliminent la plupart des problèmes rencontrés avec les langages dotés d'un espace de noms global , bien que certains problèmes puissent persister sans encapsulation appropriée. Sans verrouillage approprié (comme avec un mutex ), le code utilisant des variables globales ne sera pas thread-safe, à l'exception des valeurs en lecture seule dans la mémoire protégée .

Les variables d'environnement sont une fonctionnalité fournie par certains systèmes d'exploitation . Dans le shell du système d'exploitation ( ksh sous Unix , bash sous Linux , COMMAND.COM sous DOS et CMD.EXE sous Windows ), elles constituent une sorte de variable : par exemple, sous Unix et les systèmes apparentés, une variable ordinaire devient une variable d'environnement lorsque le exportmot-clé est utilisé. Le code de programme autre que les shells doit y accéder par des appels d'API , tels que getenv()et setenv().

Elles sont locales au processus dans lequel elles ont été définies. Cela signifie que si nous ouvrons deux fenêtres de terminal (deux processus différents exécutant le shell) et modifions la valeur de la variable d'environnement dans une fenêtre, cette modification ne sera pas visible par l'autre fenêtre.

Lorsqu'un processus enfant est créé, il hérite de toutes les variables d'environnement et de leurs valeurs du processus parent. En général, lorsqu'un programme appelle un autre programme, il crée d'abord un processus enfant en le forçant , puis l'enfant ajuste l'environnement selon les besoins et enfin il se remplace par le programme à appeler. Les processus enfants ne peuvent donc pas utiliser de variables d'environnement pour communiquer avec leurs homologues, évitant ainsi le problème de l'action à distance.

Un certain nombre de langages non structurés , tels que les premières versions de BASIC , COBOL et Fortran I (1956), ne fournissent que des variables globales. Fortran II (1958) a introduit des sous-routines avec des variables locales et le mot-clé COMMON pour accéder aux variables globales. L'utilisation de COMMON dans FORTRAN a continué dans FORTRAN 77, et a influencé des langages ultérieurs tels que PL/SQL. Les groupes COMMON nommés pour les variables globales se comportent un peu comme des espaces de noms structurés. Les variables sont également globales par défaut dans Forth , Lua , Perl et la plupart des shells.

Le langage C n'a pas de global mot-clé . Cependant, les variables déclarées en dehors d'une fonction ont une « portée de fichier », ce qui signifie qu'elles sont visibles dans le fichier. Les variables déclarées avec une portée de fichier sont visibles entre leur déclaration et la fin de l'unité de compilation ( .cfichier) (à moins qu'elles ne soient masquées par un objet du même nom dans une portée plus proche, comme une variable locale) ; et elles ont implicitement un lien externe et sont donc visibles non seulement pour le .cfichier ou l'unité de compilation contenant leurs déclarations, mais aussi pour toute autre unité de compilation liée pour former le programme complet. Le lien externe, cependant, n'est pas suffisant pour l'utilisation d'une telle variable dans d'autres fichiers : pour qu'une unité de compilation accède correctement à une telle variable globale, elle devra connaître son type. Cela est accompli en déclarant la variable dans chaque fichier à l'aide du externmot-clé . (Elle sera déclarée dans chaque fichier mais ne pourra être définie que dans un seul.) De telles externdéclarations sont souvent placées dans un fichier d'en-tête partagé, car il est courant que tous .cles fichiers d'un projet incluent au moins un .hfichier : le fichier d'en-tête standard errno.hest un exemple, rendant la errnovariable accessible à tous les modules d'un projet. Lorsque ce mécanisme d'accès global est jugé problématique, il peut être désactivé à l'aide du staticmot-clé qui restreint une variable à la portée du fichier et provoquera des tentatives d'importation avec externpour résultat une erreur de compilation (ou de liaison).

Un exemple de variable « globale » en C :

#include <stdio.h>
// Il s'agit de la variable de portée de fichier (avec lien interne), visible uniquement dans 
// cette unité de compilation. 
static int shared = 3 ;
// Celui-ci a un lien externe (non limité à cette unité de compilation). 
extern int over_shared ;
// Également un lien interne. 
int over_shared_too = 2 ;
static void ChangeShared () { // Référence à la variable de portée de fichier dans une fonction. shared = 5 ; }
static void LocalShadow () { // Variable locale qui masquera la variable globale du même nom. int shared ;
// Cela affectera uniquement la variable locale et n'aura aucun effet sur la 
variable de portée de fichier du même nom. shared = 1000 ; }
static void ParamShadow ( int shared ) { // Cela affectera uniquement le paramètre et n'aura aucun effet sur la variable de portée de fichier du même nom. shared = - shared ; }
int main () { // Référence à la variable de portée de fichier.
printf ( "%d " , partagé );
ChangerPartagé ();
printf ( "%d " , partagé );
OmbreLocale ();
printf ( "%d " , partagé );
ParamShadow ( 1 );
printf ( "%d " , partagé );
retourner 0 ; }

Comme la variable est externe, il n'est pas nécessaire de la passer en paramètre pour l'utiliser dans une fonction autre que main. Elle appartient à chaque fonction du module.

Le résultat sera :

3 5 5 5 

Certains langages, comme Java, n'ont pas de variables globales. En Java, toutes les variables qui ne sont pas des variables locales sont des champs d'une classe. Par conséquent, toutes les variables sont dans la portée d'une classe ou d'une méthode. En Java, les champs statiques (également appelés variables de classe ) existent indépendamment de toute instance de la classe et une copie est partagée entre toutes les instances ; par conséquent, les champs statiques publics sont utilisés pour de nombreuses fins similaires aux variables globales dans d'autres langages en raison de leur comportement de « partage » similaire :

classe publique Global { public static int a ; }

PHP possède un globalmot-clé et un certain nombre de façons inhabituelles d'utiliser les variables globales. Les variables déclarées en dehors des fonctions ont une portée de fichier (qui est, dans la plupart des cas, la portée la plus large). Cependant, elles ne sont pas accessibles à l'intérieur des fonctions à moins d'être importées avec le globalmot-clé (c'est-à-dire que le mot-clé accède aux variables globales, il ne les déclare pas).

Cependant, certaines variables prédéfinies, appelées superglobales , sont toujours accessibles. Ce sont toutes des tableaux. Le superglobal est un tableau à usage général $GLOBALSqui contient toutes les variables définies hors de la portée de la fonction. Les modifications apportées à ses éléments modifient les variables d'origine et les ajouts créent de nouvelles variables. Les superglobales $_POSTsont $_GETlargement utilisées dans la programmation Web.

• En Python et MATLAB, une variable globale peut être déclarée n'importe où avec le globalmot-clé.
• Les variables globales de Ruby se distinguent par un sigil$ ' ' . Il existe un certain nombre de variables globales prédéfinies, par exemple l' ID du processus actuel .$$