Réponse.

La portée d'une variable (scope) en C définit la section de code dans laquelle la variable est accessible. Historiquement, depuis les premières versions du langage C, le support des portées locales et globales a permis de structurer les programmes, de réduire les erreurs dues à la redéfinition des variables et d'améliorer la lisibilité du code.

Problème : Sans une compréhension et une utilisation adéquates de la portée, des erreurs peuvent survenir, telles que la redéfinition accidentelle des variables, des difficultés de maintenance et d'extension du code, ainsi que des bogues liés au fonctionnement non évident des variables.

Solution : Utiliser correctement différentes portées : la portée de bloc (à l'intérieur des accolades), la portée de fonction, la portée de fichier (à l'aide de static), et la portée globale. Cela permet de minimiser l'impact d'une partie du code sur les autres et réduit la probabilité d'effets secondaires.

Exemple de code :

int global_var = 10;

void foo() {
    int block_var = 5;
    if (block_var > 3) {
        int inner_var = 2;
        printf("inner_var: %d\n", inner_var);
    }
    // inner_var n'est pas accessible ici — en dehors de son bloc
}

Caractéristiques clés :

• La portée locale limite la variable au bloc actuel.
• Les variables globales sont visibles dans toutes les fonctions du fichier (ou dans tous les fichiers — lorsqu'elles sont déclarées avec extern).
• Les variables static limitent la portée au fichier ou à la fonction selon l'endroit de la déclaration.

Questions pièges.

Peut-on accéder à une variable locale depuis une autre fonction via un pointeur ?

Seulement si l'on retourne l'adresse de la variable, par exemple, retourner l'adresse d'une variable locale depuis une fonction, mais cela conduira à un comportement indéfini, car la mémoire de la variable locale peut être réécrite après la fin de la fonction.

Exemple de code :

int* bad_function() {
    int temp = 42;
    return &temp; // dangereux !
}

Que se passe-t-il avec la déclaration de deux variables avec le même nom dans différentes portées ?

La règle d'occultation (shadowing) s'applique : la variable la plus proche de l'utilisation obscurcit toutes les autres avec le même nom situées plus haut dans la hiérarchie des portées.

Exemple de code :

int value = 100; // globale
void foo() {
    int value = 10; // locale, obscurcit la globale
}

Comment le spécificateur static influence-t-il la portée d'une variable dans différents endroits de déclaration ?

Si static est utilisé pour une variable à l'intérieur d'une fonction, elle devient locale tout en conservant sa valeur entre les appels (durée de vie de portée et visibilité de bloc). Si static est pour une variable globale, la visibilité est limitée au fichier actuel (file scope).

Erreurs typiques et anti-patrons

• Déclaration de variables en haut du fichier sans nécessité (variables globales au lieu de transmission via les paramètres des fonctions).
• Utilisation de noms identiques pour les variables locales et globales, ce qui complique le débogage.
• Retourner l'adresse d'une variable locale depuis une fonction.

Exemple de la vie

Cas négatif

Dans un grand projet, toutes les variables sont déclarées globalement. Quelqu'un réécrit accidentellement une variable globale depuis une autre fonction, et le programme fonctionne de manière incorrecte seulement dans un certain ordre d'appel des fonctions.

Avantages :

• Syntaxe simple, moins d'imbrication du code.

Inconvénients :

• Beaucoup d'erreurs cachées, impossible de suivre toutes les influences des variables entre les fonctions.

Cas positif

Dans chaque fonction, seules les variables locales sont utilisées, et les données nécessaires sont transmises via les paramètres des fonctions.

Avantages :

• Haute modularité, faible couplage du code, simplicité des tests.

Inconvénients :

• Parfois, il faut transmettre explicitement un grand ensemble de paramètres, augmentant la signature des fonctions.