On peut échanger des informations (des variables) entre differentes fonction grâce à la transmission d'arguments et la récupération d'une valeur en retour. Mais aussi, plusieurs fonctions (y compris main) peuvent partager des variables communes qu'on qualifie alors de "variables globales" (externes).

En C une variable globale est partagée par plusieurs fonctions (d'un même fichier), elle peut même être partagée entre plusieurs fichiers sources.

Les variables globales ne sont connues des compilateurs que dans la partie du programme source suivant leur déclaration, on dit que leur portée est illimitée à la partie du programme source qui suit leur déclaration.

D'une manière générale les variables globales existent pendant toutes l'execution du programme dans lequel elles apparaissent, leur emplacement en memoire est parfaitement défini lors de l'édition des liens, on traduit cela en disant qu'elles font partie de la classe d'allocation static, de plus elles sont initialisées à zéro avant le debut du programme sauf affectation explicite à leur déclaration.

Une variable est dite locale à la fonction dans laquelle elle est déclarée si elle est définie au sein d'une fonction (n'importe laquelle, y compris main). Les variables locales ne sont connues qu'à l'interieur de la fonction où elles sont déclarée, leur porté est donc limitée à cette fonction.

Remarque: Les variables locales n'ont aucun lien avec les variables globales de même nom ou avec d'autres variables locales à d'autres fonctions; les valeurs des variables locales ne sont pas conservées d'un appel au suivant.

Par defaut, les variables locales ont une "durée de vie" limitée à celle d'une exécution de la fonction dans laquelle elles figurent. Un nouvel espace mémoire leur est alloué à chaque entrée dans la fonction et libéré à chaque sortie.

Remarque: Les valeurs des variables locales n'étant pas conservées d'un appel au suivant, la classe d'allocation est dite "automatique", d'autre part, les valeurs transmises en arguments à une fonction sont traitées de la même manière que les variables locales. Leur durée de vie correspont également à celle de la fonction.

Il est toutefois possible de demander d'attribuer un emplacement permanent à une variable locale et qu'ainsi, sa valeur se conserve d'un appel au suivant. Il suffit pour cela de la déclarer à l'aide du mot clé "static".

Remarque: Les variables locales statiques sont par defaut initialisées à zero.(variable locale statique different de variable globale).

Nous avons vu que la déclaration d'un paramètre ou d'une variable de bloc annule localement la déclaration de toute variable de même nom faite à l'exterieur de ce bloc. Ainsi :

int i; /*i entier global */                  /* début fichier */
double lereel;  /* global */
int f(long i) /*i entier long local à f*/    /* début bloc A */
  {
    float lereel;
      {                                       /* début bloc imbriqué B */
        double lereel;
      }                                       /* fin bloc B */
  }                                           /* fin bloc A */
void AutreFonction(void)
  {
                                              /* bloc C */
  }
void main(void)
  { 
                                              /* bloc D */
  }                                           /* fin fichier */

Interprétation

• Les variables globales au fichier (i et lereel) ne sont visibles que des blocs D et C, car dans les autres elles sont cachées par d'autres variables locales de même nom.
• Le paramètre i (entier) de la fonction f() n'est visible que du bloc A (et donc aussi B, qui est imbriqué dans A).
• La variable du bloc B n'est visible que de B.
• lereel représente trois variables distinctes suivant que l'on se trouve dans A, dans B, ou dans C ou D.

# include <stdio.h >
void affiche(void)
  {
    int LeNombre =0;
    LeNombre++ ;
    (void) printf ("%d", LeNombre);
  }
int main(void)
  {
    int indice=0;
    while(++indice<10)
         affiche();
    (void) printf("\n");
    return 0;
  }

Interprétation

Dans la fonction affiche, la variable LeNombre est de classe "auto" donc elle est créée et initialisée à chaque appel. On affiche donc dix fois "1".

Par contre

# include <stdio.h > 
void affiche(void)
  {
    static int LeNombre =0;
    LeNombre++ ;
    (void) printf ("%d", LeNombre);
  }
int main(void)
  {
    int indice=0;
    while(++indice<10)
          affiche();
    (void) printf("\n");
    return 0;
  }

Ici la variable LeNombre est de classe "static" aussi elle a été créée et initialisée à la compilation, et existe tant que dure la tâche; elle conserve donc sa valeur entre chaque appel. On affiche donc de 1 à 10.

retour au sommaire