Subsections

• 5.1 Variables globales et locales
  • 5.1.1 Les variables locales statiques
  • 5.1.2 Les variables critiques
  • 5.1.3 Les variables constantes et volatiles
• 5.2 La modularité
  • 5.2.1 Variables globales privées et publiques
    • Variables externes
  • 5.2.2 Fonctions privées et publiques
    • Fonctions externes

  5 Classification des données

    Nous avons jusqu'à présent associé aux variables un type particulier. Cet attribut n'est pas le seul que l'on assigne à une variable: il y a également la classification qui est un autre attribut important. Cette classification détermine l'emplacement mémoire où la variable sera stockée.

  Les variables ne sont pas les seules entités possédant l'attribut de classification: il en est de même des fonctions (voir chapitre 4).

  5.1 Variables globales et locales

      Selon l'emplacement de la défintion d'une variable, celle-ci est soit une variable locale, soit une variable globale.

  Toute variable définie à l'extérieur des fonctions est une variable globale. Comme nous l'avons dit (voir section 1.6), les variables globales ne sont pas les seules variables possibles: les variables définies à l'intérieur des fonctions sont des variables locales.

  Une variable globale est connue donc utilisable dans n'importe quelle partie du fichier où elle est définie; en particulier à l'intérieur de n'importe quelle fonction du module. Cette portée peut même s'étendre à d'autres modules du programme, si le programme est constitué de plusieurs fichiers (voir section 5.2.1).

  Un bloc est une suite de déclarations suivies par des instructions, le tout encadré par une accolade ouvrante { et une accolade fermante }. Le corps d'une fonction est encadré par des accolades: c'est donc une bloc. Une variable locale est définie à l'intérieur d'une fonction et au début d'un bloc (c'est le seul endroit où il est permis de définir des variables locales). Une variable locale n'est connue qu'à l'intérieur du bloc dans lequel elle est définie.

   
  int g;                         g est une variable globale
  
  main() {
       int i;                    i est une variable locale
       for (i=1; i<=100; i++) {
           int j;                j est une variable locale
           for (j=1; j<=100; j++) {
                g = pcgd(i, j);  i, j  et g sont accessibles ici
                printf("Le pgcd de %d et de %d est %d
  
   $\backslash$ n", i, j, g);
                ...
           }                    j n'est plus accessible à partir d'ici
          ...
      }                         i n'est plus accessible à partir d'ici
  }
   

  Il n'y a aucune restriction syntaxique dans le choix des noms de variables globales ou locales; il est donc possible de définir (par inadvertance, le plus souvent) une variable locale et une variable globale ayant le même nom. Le compilateur C ne génèrera pas d'erreur. Dans la portée de la variable locale, c'est la variable locale qui sera choisie; sinon c'est la variable globale. Par exemple, le programme suivant affichera 150 puis 100.

   
  int g = 100;               g est une variable globale
  
  main() {
       if (g==0)  {         Il s'agit de la variable globale
           int g = 50;       g est une variable locale
           printf("%d", g);  Il s'agit de la variable locale
       }
       else
           printf("%d", g);  Il s'agit de la variable globale
  }
   

  Il en est de même pour une variable globale et un paramètre formel.

   
  int g = 100;               g est une variable globale
  
  void qqchose(int g)  {    Il s'agit d'un paramètre formel
       if (g==0)             g est le paramètre formel
          ....
  }
   

  Même remarque pour deux variables locales de même nom.

   
  main() {
       int g = 100;          g est une variable locale
       if (g==0) {
           int g = 50;       g est une variable locale
           printf("%d", g);  qui masque la déclaration précédante
       }
       else
           printf("%d", g);  Il s'agit de la première variable locale
  }
   

  On retiendra de ceci que      
  • Les variables globales sont statiques (static) c'est-à-dire qu'elles sont permanentes: elles existent toute la durée de l'exécution du programme. Au démarrage du programme, le système alloue l'espace nécessaire et effectue les initialisations. Tout cet espace sera rendu au système lors de la terminaison du programme.
  • les variables locales et les arguments formels des fonctions sont automatiques. L'espace nécessaire est alloué lors de l'activation de la fonction ou du bloc correpondant; il est restitué au système à la fin du bloc ou de la fonction. Comme nous le verrons plus loin, les qualifieurs static, register permettent de modifier l'allocation et la durée de vie de ces variables.

    Les arguments formels des fonctions se comportent comme des variables locales qui ont la particularité d'être automatiquement initialisés par les arguments effectifs lors de l'activation de la fonction.

  5.1.1 Les variables locales statiques

   Le qualifieur static placé devant la définition d'une variable locale la rend static c'est-à-dire permanente, mais sa visibilité reste locale. Elle n'est ``accessible'' (par son nom) qu'à l'intérieur du bloc où elle est définie. Comme elle est permanente, elle sera stockée avec les variables globales. Deux appels à un même bloc (ou fonction) contenant une variable locale static utilisent la même variable et la valeur rangée dans cette variable sont conservées.

  L'inérêt des variables locales static est d'interdire des modifications inconsidérées (comme on pourrait le faire sur des variables globales) et de n'autoriser ces modifications qu'à l'intérieur de la fonction ou bloc où elle est définie.

  Il faut toutesfois utiliser les variables static avec beaucoup de précaution. En particulier, elles sont mal adaptées aux fonctions récursives.

  5.1.2 Les variables critiques

   Le qualifieur register placé devant la définition d'une variable informe que celle-ci joue un rôle critique pour le programme et que l'on attend du compilateur qu'il optimise son utilisation. Les variables register doivent être locales et d'un type élémentaire. Elles sont automatiquement initialisées à 0. L'optimisation de l'utilisation d'une telle variable dépend de l'architecture de la machine; dans beaucoup de cas, elles sont stockées dans des registres de la machine et non pas en mémoire centrale. Le nombre de registres étant limité sur toutes les machines, le compilateur accorde ce traitement spécial aux variables dans l'ordre où elles figurent dans les déclarations.

   
  int strlen(char chaine[]) {
      register int i=0;
      while (chaine[i] != 0) i++;
      return i;
  }
   

  L'intérêt du qualifieur register est très limité dans la mesure où les compilateurs actuels sont assez sophistiqués pour déterminer (parfois mieux que le programmeur lui-même) les variables qui sont critiques et pour faire les optimisations adéquates.

  Ce qualifieur peut et doit être évité avec des compilateurs récents et évolués.

  5.1.3 Les variables constantes et volatiles

       Le qualifieur const placé devant la définition d'une variable précise au compilateur que la variable ou l'argument formel ne changera pas de valeur tout au long du programme ou dans la portée de la déclaration (fonction ou bloc). Ceci permet au compilateur d'effectuer des traitements plus efficaces.

  Il est toujours conseillé d'utiliser ce qualifieur chaque fois que cela est possible.

  Le qualifieur volatile placé devant la définition d'une variable précise au compilateur que la variable peut être modifée de manière ``mystérieuse'' par des interruptions ou autre fonctions du système. Ce renseignement fait que le compilateur s'interdit des optimisations qu'elle aurait effectuées sans ce qualifieur.

  5.2 La modularité

  5.2.1 Variables globales privées et publiques

      Dans cette section, on s'intéresse aux programmes constitués de plusieurs modules. Comme nous l'avons déjà dit, les variables locales et les arguments formels ne sont visibles quà l'intérieur de la portée de leur déclaration. Il va de soi qu'ils ne peuvent donc pas être visibles d'un autre module. Qu'en est-il des variables globales ?

  Toutes les variables globales sont publiques c'est-à-dire qu'elles peuvent (moyennant une déclaration spécifique) être utilisées dans les autres modules. On peut interdire cette facilité en donnant à ces variables le qualifieur static. On dit alors qu'il s'agit d'une variable privée.

  Le qualifieur static d'une variable locale change la durée de vie de celle-ci. Le qualifieur static d'une variable globale restreint sa visibilité au seul module dans lequel elle est définie.

  On peut donc avoir un même nom pour deux variables globales privées à condition qu'elles figurent dans deux modules différents: ces deux variables sont alors différentes.

  Dans un programme composé de plusieurs modules, il faut à tout prix utiliser ce qualifieur static pour rendre privé toutes les variables qui doivent l'être. Sinon, on risque de partager à tort des variables privés.

  Variables externes

   

  Comme nous l'avons déjà dit dans la section 1.6, une définition crée physiquement l'objet correspodant alors qu'une déclarartion se limite à indiquer (pour les besoins de la compilatation) que l'objet existera et sera défini plus loin dans le même module ou dans un autre module.

  Le qualifieur extern placé devant la déclaration d'une variable ou d'une fonction informe que celui-ci sera défini plus loin dans le même module ou dans un autre module.

  A chaque variable, il ne peut y avoir qu'une seule définition. Par contre, il peut y avoir plusieurs déclarations dans le même module ou dans d'autres modules.

  5.2.2 Fonctions privées et publiques

      Comme pour les variables globales, les fonctions peuvent être privées ou publiques. Une fonction privée ne peut être appelée que par des fonctions qui figurent dans le même module. Par contre, une fonction publique peut être appelée par n'importe quelle fonction du programme.

  Toutes les fonctions sont publiques c'est-à-dire qu'elles peuvent (moyennant une déclaration spécifique, voir plus loin) être utilisées dans les autres modules. On peut interdire cette facilité en donnant à ces fonctions le status static. On dit alors qu'il s'agit d'une fonction privée.

  On peut donc avoir un même nom pour deux fonctions privées à condition qu'elles figurent dans deux modules différents. Ceci permet, en particulier, de developper des programmes à plusieurs: il suffit de s'entendre sur les noms des seules fonctions publiques et le choix de noms des fonctions privées peut être laissé aux multiples programmeurs du programme, en étant assuré qu'il n'y aura pas de collision de noms.

  Dans un programme composé de modules, il faut à tout prix utiliser ce qualifieur static pour rendre privées toutes les fonctions qui doivent l'être.

  Fonctions externes

         

  Comme nous l'avons déjà dit dans la section 1.6, une défintion crée physiquement l'objet correspodant alors qu'une déclarartion se limite à indiquer (pour les besoins de la compilation) que l'objet existera et sera défini plus loin dans le même module ou dans un autre module.

  Le qualifieur extern placé devant la déclaration d'une fonction informe que celle-ci sera définie plus loin dans le même module ou dans un autre module.

  A chaque fonction, il ne peut y avoir qu'une seule définition. Par contre, il peut y avoir plusieurs déclarations dans le même module ou dans d'autres modules.