Réponse.

La portée (scope) et la durée de vie (lifetime) des variables sont parmi les aspects clés de la structure d'un programme en C. La portée définit la partie du code où une variable est accessible par son nom. La durée de vie détermine quand une variable existe réellement en mémoire.

Histoire de la question
Le C a été conçu pour un contrôle de bas niveau, il offre donc une approche flexible mais dangereuse de la portée et des durées de vie grâce à la classification des variables selon leur déclaration (locale, fichier, globale, statique).

Problème
Une compréhension incorrecte de la portée/de la durée de vie conduit à des bugs classiques : tentatives d'accès à des variables inaccessibles ou déjà détruites (use-after-free), conflits de noms entre les variables globales et locales (variables fantômes), modification involontaire de variables globales.

Solution
Définir explicitement le type de stockage requis (auto, static, extern), utiliser raisonnablement la portée de bloc, minimiser le nombre de variables globales, distinguer clairement la durée de vie entre heap et stack.

Exemple de code :

int global_var;      // Globale, vit toute la durée d'exécution

void func() {
    int local_var = 5; // Automatique, vit dans func()
    static int stat_var = 0; // Statique, vit entre les appels
    stat_var++;
}

Caractéristiques clés :

Portée de bloc pour les variables locales : les variables ne sont accessibles que dans le bloc où elles sont déclarées.
Les variables globales vivent toute la durée d'exécution du programme et sont visibles depuis n'importe quel fichier lors de la déclaration extern (à moins que ce ne soit static).
Les variables locales statiques conservent leur valeur entre les appels de la fonction, mais ne sont accessibles que dans la fonction.

Questions piégeuses.

Que se passe-t-il si deux variables avec le même nom sont déclarées dans des blocs différents ?

La variable interne masquera l'externe (variable fantôme). Cela peut conduire à des bugs inattendus.

int x = 10;
...
if (1) {
    int x = 50;
    printf("%d", x); // affiche 50, le x global est masqué
}

Quelle est la durée de vie d'une variable automatique définie à l'intérieur d'une fonction ?

Elle n'existe que pendant l'appel de la fonction. Après la sortie, la mémoire est libérée, et la valeur est perdue.

Une variable locale statique peut-elle être utilisée en dehors de la fonction où elle est déclarée ?

Non, sa portée n'est que dans la fonction. Elle est invisible de l'extérieur, bien que sa durée de vie soit toute la durée d'exécution du programme.

void f() {
    static int x = 0;
}
// Inaccessible en dehors de f()

Erreurs typiques et anti-patterns

Utilisation de variables locales après la sortie d'un bloc.
Supposition erronée sur la durée de vie des variables (static vs auto).
Utilisation excessive de variables globales.

Exemple de la vie réelle

Cas négatif

Un développeur débutant crée un compteur à l'intérieur d'une boucle comme statique, et ce compteur « cumule » des valeurs entre les itérations, alors qu'il était prévu de le réinitialiser à chaque fois.

Avantages :

On peut explorer le comportement de la variable en conservant son état.

Inconvénients :

La logique de l'algorithme est compromise, difficile à déboguer.

Cas positif

Le développeur utilise static uniquement pour le caching, et pour les besoins temporaires - des variables auto ordinaires.