Partager via

Spécificateur de classe de stockage pour les déclarations de Niveau extérieurement

  • Article

Les variables externes sont des variables au niveau de la portée du fichier.Ils sont définis en dehors de toute fonction, et ils peuvent être disponibles pour de nombreuses fonctions.Les fonctions peuvent être définies au niveau externe et ne peuvent pas, par conséquent, être imbriquées.Par défaut, toutes les références aux variables externes et fonctions du même nom sont des références au même objet, ce qui signifie qu'ils possèdent la « liaison externe. » (Vous pouvez utiliser le mot clé de statique pour substituer ce.Afficher des informations plus loin dans cette section pour plus de détails sur statique.)

Les déclarations de variable au niveau externe sont des définitions de variables (« définissant des déclarations »), ou des références aux variables définies ailleurs (« référençant les déclarations »).

Une déclaration de variable externe qui initialise également la variable (implicitement ou explicitement) est une déclaration de définition de la variable.Une définition au niveau externe peut prendre plusieurs formes :

  • Une variable déclarée avec le spécificateur de classe de stockage de statique .vous pouvez explicitement initialiser la variable de statique avec une expression constante, comme décrit dans initialisation.si vous omettez l'initialiseur, la variable est initialisée à 0 par défaut.Par exemple, ces deux instructions sont les deux définitions considérées comme d' kvariable.

    static int k = 16;
static int k;

  • une variable que vous initialisez explicitement au niveau externe.par exemple, int j = 3; est une définition d' jvariable.

Dans les déclarations de variable au niveau externe (autrement dit, en dehors de toutes les fonctions), vous pouvez utiliser le spécificateur de classe de stockage de statique ou d' extern ou omettre le spécificateur de classe de stockage entièrement.Vous ne pouvez pas utiliser les feuillesde stockage-classe-spécificateur d' auto  et de registreau niveau externe.

Une fois qu'une variable est définie au niveau externe, elle est visible dans le reste de l'unité de traduction.la variable n'est pas visible avant sa déclaration dans le même fichier source.En outre, il n'est pas visible dans d'autres fichiers sources du programme, à moins qu'une déclaration qui référence le rendre visible, comme décrit ci-dessous.

Les règles concernant statique incluent :

  • Les variables déclarées à l'extérieur de tous les blocs sans mot clé de statique conservent toujours leurs valeurs dans l'ensemble du programme.Pour limiter leur accès à une unité de traduction particulière, vous devez utiliser le mot clé de statique .Cela leur confère « la liaison interne. » Pour les rendre globaux à un programme entier, omettre la classe de stockage explicite ou utiliser le mot clé extern (consultez les règles dans la liste suivante).Cela leur permet la « liaison externe. » Interne et liaison externe sont également traités dans liaison.

  • Vous pouvez définir une variable au niveau externe uniquement une fois à l'intérieur d'un programme.Vous pouvez définir une autre variable portant le même nom que le spécificateur de classe de stockage de statique dans une unité de traduction différente.Étant donné que chaque définition de statique est visible que dans sa propre unité de traduction, aucun conflit ne se produit.Cela offre un moyen utile de masquer les noms d'identificateurs qui doivent être partagés entre des fonctions d'une seule unité de traduction, mais non visible à d'autres unités de traduction.

  • le spécificateur de classe de stockage de statique peut s'appliquer aux fonctions également.Si vous déclarez une fonction statique, son nom est invisible en dehors de le fichier dans lequel il est déclaré.

Les règles d'utilisation d' extern sont :

  • le spécificateur de classe de stockage d' extern déclare une référence à une variable définie ailleurs.Vous pouvez utiliser une déclaration d' extern pour rendre une définition dans un autre fichier source visible, ou pour rendre une variable visible avant sa définition dans le même fichier source.Une fois que vous avez déclaré une référence à la variable au niveau externe, la variable est visible dans le reste de l'unité de traduction dans laquelle la référence déclarée se produit.

  • Pour qu'une référence d' extern soit valide, la variable qu'il fait référence doit être définie une seule fois, et qu'une seule fois, au niveau externe.Cette définition (sans classe de stockage d' extern ) peut être dans les unités de traduction l'une des qui composent le programme.

Exemple

l'exemple ci-dessous montre des déclarations externes :

/******************************************************************
                      SOURCE FILE ONE 
*******************************************************************/
#include <stdio.h>

extern int i;                // Reference to i, defined below 
void next( void );           // Function prototype            

int main()
{
    i++;
    printf_s( "%d\n", i );   // i equals 4 
    next();
}

int i = 3;                  // Definition of i

void next( void )
{
    i++;
    printf_s( "%d\n", i );  // i equals 5
    other();
}

/******************************************************************
                      SOURCE FILE TWO 
*******************************************************************/
#include <stdio.h>

extern int i;              // Reference to i in 
                           // first source file 
void other( void )
{
    i++;
    printf_s( "%d\n", i ); // i equals 6 
}

les deux fichiers sources dans cet exemple contiennent un total de trois déclarations externes d' i.Qu'une déclaration est « définir la déclaration. » cette déclaration,

int i = 3;

définit la variable globale i et l'initialise avec la valeur initiale 3.« Référencer » la déclaration d' i en haut du premier fichier source à l'aide extern rend la variable globale visible avant sa déclaration de définition dans le fichier.La déclaration qui référence d' i dans le deuxième fichier source rend également la variable visible dans ce fichier source.Si une instance de définition pour une variable n'est pas fournie dans l'unité de traduction, le compilateur suppose qu'il existe

extern int x;

référençant la déclaration et qu'une référence de définition

int x = 0;

apparaît dans une autre unité de traduction du programme.

Les trois fonctions, main, next, et other, effectue la même tâche : augmentent i et l'imprimer.les valeurs 4, 5, et 6 sont imprimées.

si i variable n'avait pas été initialisé, il aurait été défini à 0 automatiquement.Dans ce cas, les valeurs 1, 2 et 3, aurait été imprimées.Consultez l' initialisation pour plus d'informations sur l'initialisation variable.

Voir aussi

Référence

Classes de stockage C