Variables locales et globales en langage C

Portée des variables

1. Variables locales

Exemple n°1 — Variable locale inaccessible depuis une autre fonction

void fonction_1(void)
{
    int a = 10, b = 20;   /* a et b : locales à fonction_1 */
    printf("a = %d, b = %d\n", a, b);
}

void fonction_2(void)
{
    /* printf("%d\n", a); */  /* ERREUR — a n'existe pas ici */
    printf("fonction_2 ne connaît pas a ni b\n");
}

void f1(void) { int x = 1; printf("%d\n", x); }  /* x propre à f1 */
void f2(void) { int x = 2; printf("%d\n", x); }  /* x propre à f2 — aucun conflit */

Exemple n°2 — Variable locale à un bloc if

#include <stdio.h>

int main(void)
{
    int n = 7;

    if (n > 0) {
        int double_n = n * 2;      /* locale au bloc if */
        printf("double_n = %d\n", double_n);
    }

    /* printf("%d\n", double_n); */  /* ERREUR — hors du bloc if */
    return 0;
}

double_n = 14

int somme;                       /* valeur indéfinie */
somme += 5;                      /* résultat imprévisible */

int somme = 0;                   /* correct — toujours initialiser */
somme += 5;                      /* résultat : 5 */

2. Variables globales

Exemple n°3 — Variable globale partagée entre deux fonctions

#include <stdio.h>

int a;   /* variable globale — initialisée à 0 par défaut */

void fonction_1(void)
{
    a = 5;
    printf("Fonction 1 — a = %d\n", a);
}

void fonction_2(void)
{
    printf("Fonction 2 — a = %d\n", a);
}

int main(void)
{
    fonction_1();
    fonction_2();
    printf("bye\n");
    return 0;
}

Fonction 1 — a = 5
Fonction 2 — a = 5
bye

La modification de a dans fonction_1 est visible par fonction_2 car elles partagent la même variable globale.

Masquage de la variable globale

Si une variable locale porte le même nom qu'une variable globale, la variable locale prend la priorité (masquage) à l'intérieur de sa portée. La variable globale reste inchangée.

Exemple n°4 — Variable locale masquant la variable globale

#include <stdio.h>

int a = 0;   /* variable globale */

void fonction_1(void)
{
    int a = 3;   /* variable locale — masque le a global */
    printf("Fonction 1 — a local  = %d\n", a);   /* 3 */
}

void fonction_2(void)
{
    printf("Fonction 2 — a global = %d\n", a);   /* 0 */
}

int main(void)
{
    fonction_1();
    fonction_2();
    printf("bye\n");
    return 0;
}

Fonction 1 — a local  = 3
Fonction 2 — a global = 0
bye

gcc -Wall -Wshadow programme.c -o programme

3. Paramètres formels

Exemple n°5 — Paramètre formel masquant la variable globale

#include <stdio.h>

int a = 0;   /* variable globale */

void fonction_1(int a)   /* paramètre formel nommé 'a' — masque le global */
{
    a = 3;
    printf("Fonction 1 — a (paramètre) = %d\n", a);   /* 3 */
}

void fonction_2(void)
{
    printf("Fonction 2 — a (global)    = %d\n", a);   /* 0 — inchangé */
}

int main(void)
{
    fonction_1(a);   /* passe la valeur 0, mais le paramètre est local */
    fonction_2();
    printf("bye\n");
    return 0;
}

Fonction 1 — a (paramètre) = 3
Fonction 2 — a (global)    = 0
bye

Le paramètre a de fonction_1 est une copie locale de la valeur passée. La modifier n'affecte pas la variable globale a — c'est le passage par valeur.

4. Initialisation des variables locales et globales

Valeurs par défaut des variables globales (initialisation automatique) :

Exemple n°6 — Contraste initialisation globale vs locale

#include <stdio.h>

int compteur_global;   /* initialisée à 0 automatiquement */

void afficher(void)
{
    int compteur_local;   /* NON initialisée — valeur imprévisible */
    printf("global = %d\n", compteur_global);
    printf("local  = %d\n", compteur_local);   /* résultat indéfini */
}

int main(void)
{
    afficher();
    return 0;
}

int somme;        /* dangereux — valeur inconnue */
int somme = 0;    /* correct  — toujours initialiser */

Récapitulatif