Réponse.

Historique de la question :

Les variables globales et locales ont été introduites en C pour gérer la mémoire et la portée du code. Les variables globales étaient auparavant le principal moyen d'échanger des données entre les fonctions avant l'avènement de la programmation modulaire, tandis que les locales ont permis de réduire l'interaction et d'augmenter l'isolation du code.

Problème :

Il y a souvent une confusion sur les différences entre les variables globales et locales : leurs durées de vie, leurs portées, les règles et le temps d'initialisation. Les variables globales entraînent des problèmes de synchronisation et de lisibilité, tandis que les locales conduisent à l'inaccessibilité des données nécessaires. Les erreurs dans la compréhension de ces différences conduisent à des bugs et compliquent l'évolutivité du code.

Solution :

Les variables globales sont déclarées en dehors de toutes les fonctions et sont accessibles dans tous les fichiers lorsqu'on utilise extern. Leur durée de vie est celle de tout le programme, et l'initialisation est faite soit implicitement à zéro (pour les variables statiques), soit explicitement avec une valeur fournie par l'utilisateur. Les variables locales sont déclarées à l'intérieur des fonctions, leur durée de vie est limitée à l'appel de la fonction et leur contenu n'est pas initialisé automatiquement.

Exemple de code :

int g_var = 42; // Variable globale

void foo() {
    int l_var = 5; // Variable locale
}

Caractéristiques clés :

Variables globales : durée de vie — tout le programme, portée — tous les fichiers (avec extern), auto-initialisation à zéro (si non spécifié).
Variables locales : durée de vie — corps de fonction (ou bloc), portée — uniquement à l'intérieur du bloc, non initialisées par défaut.
Les erreurs surviennent lors de la collision de noms, de l'accès accidentel et du contenu indéfini des variables locales.

Questions pièges.

Une variable locale est-elle automatiquement initialisée à zéro si aucune valeur initiale n'est spécifiée ?

Non. Seules les variables globales et statiques sont initialisées à zéro par défaut. Les variables locales contiennent des "déchets" (valeur indéfinie) à moins qu'une valeur de départ ne soit explicitement définie.

Exemple :

void test() {
    int a;
    printf("%d\n", a); // Comportement indéfini
}

Peut-on toujours accéder à une variable globale depuis différents fichiers ?

Non. Si la variable est déclarée comme static en dehors d'une fonction, elle n'est visible que dans ce fichier source. Si une visibilité globale est nécessaire, utilisez extern.

Peut-on déclarer une variable globale à l'intérieur d'une fonction ?

Non. À l'intérieur d'une fonction, toutes les déclarations sont locales. Les variables globales ne peuvent être créées qu'en dehors des fonctions.

Erreurs typiques et anti-patterns

Utilisation de variables locales non initialisées.
Utilisation excessive de variables globales — conduit à un entretien difficile et à des erreurs de synchronisation.
Les erreurs de nommage entraînent une ombre des variables.

Exemple de la vie réelle

Cas négatif

Une variable globale est utilisée pour échanger des données entre des fonctions :

int error_code;
void f1() { error_code = 1; }
void f2() { if (error_code) ... }

Avantages :

Solution rapide et simple, pas besoin de passer de paramètres.

Inconvénients :

Facile à oublier d'initialiser, possibilité de redéfinition accidentelle et la multi-threading devient dangereuse.

Cas positif

Toutes les variables sont locales, les données sont passées via les paramètres de fonction :

void f1(int *err) { *err = 1; }
void f2(int err) { if (err) ... }