Réponse.

En langage C, la zone de stockage des variables détermine où les données sont stockées, combien de temps elles sont accessibles et quelle partie du code peut y accéder. Historiquement, les mots clés auto (par défaut pour les variables locales), static (conserve la valeur entre les appels, souvent utilisé pour maintenir l'état) et extern (déclare une variable définie ailleurs) ont été introduits pour contrôler la visibilité et la durée de vie des variables.

Problème — Une mauvaise compréhension de l'endroit où et combien de temps vit une variable peut entraîner des erreurs d'accès, des fuites de mémoire et un code difficile à lire. Par exemple, s'attendre par erreur à ce qu'une variable locale static soit recréée à chaque appel de fonction, ou inversement, qu'une variable auto conserve sa valeur entre les appels.

Solution — Toujours choisir consciemment le spécificateur de stockage et comprendre ses conséquences :

auto est généralement inutile (c'est le défaut),
static pour conserver une valeur entre les appels ou pour restreindre la visibilité dans un module,
extern pour accéder aux variables globales définies dans d'autres fichiers.

Exemple d'utilisation :

// main.c
int global_var = 42; // a une zone de stockage static par défaut, lien externe

void func() {
    static int counter = 0; // vit entre les appels
    auto int temp = 5; // local, auto n'a pas besoin d'être mentionné
    counter++;
    printf("appel #%d\n", counter);
}

extern int global_var;

Caractéristiques clés :

auto : la variable vit jusqu'à la fin du bloc (scope) dans lequel elle est déclarée.
static : la variable vit tout au long du programme, mais est visible uniquement à l'intérieur du fichier/fonction/bloc.
extern : la variable est déclarée, mais non définie ici, sa définition est dans un autre fichier.

Questions pièges.

Pourquoi écrire auto, alors que les variables sont déjà auto par défaut ?

Réponse : Dans les versions modernes de C, le mot clé auto est presque jamais utilisé explicitement — pour une variable locale, c'est le spécificateur par défaut. En général, l'écriture explicite n'apporte aucun avantage.

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

Réponse : Non, static à l'intérieur d'une fonction rend la variable locale, mais conservant l'état entre les appels. Elle n'est pas visible en dehors de la fonction.

Exemple de code :

void foo() {
    static int call_count = 0; // Non globale, mais vit entre les appels
    call_count++;
}

Que se passe-t-il si une variable est déclarée comme extern à l'intérieur d'une fonction, mais n'est définie nulle part ?

Réponse : Cela entraînera une erreur de l'éditeur de liens (linker error), car une référence à une variable globale qui n'existe pas a été déclarée.

Erreurs typiques et anti-patterns

Confondre portée et durée de vie (par exemple, s'attendre à ce que static soit local en dehors d'une fonction).
Déclarer des variables extern sans définition.
Utiliser auto sans nécessité.

Exemple de la vie réelle

Cas négatif

Dans un grand projet, les variables-modules étaient déclarées comme extern dans tous les fichiers sources, mais on oubliait de faire la définition. En conséquence — des erreurs de liaison mystérieuses, peu claires pour les développeurs débutants.

Avantages :

Permettait de référencer des variables dans plusieurs fichiers.

Inconvénients :

Difficile à maintenir.
Erreurs apparaissant uniquement après la compilation de tous les fichiers, et non au stade de l'écriture du code.

Cas positif

Les portées étaient strictement définies : chaque variable static seulement dans le module nécessaire, les extern globales déclarées dans les en-têtes et définies à un seul endroit.