Sur les variables statiques locales et globales en C ++

Primer C ++ dit

Chaque variable statique locale est initialisée avant la première exécution de la définition de l’object. La statique locale n’est pas détruite à la fin d’une fonction. ils sont détruits à la fin du programme.

Les variables statiques locales sont-elles différentes des variables statiques globales? Autre que le lieu où ils sont déclarés, quoi d’autre est différent?

void foo () { static int x = 0; ++x; cout << x << endl; } int main (int argc, char const *argv[]) { foo(); // 1 foo(); // 2 foo(); // 3 return 0; } 

comparer avec

 static int x = 0; void foo () { ++x; cout << x << endl; } int main (int argc, char const *argv[]) { foo(); // 1 foo(); // 2 foo(); // 3 return 0; } 

Les différences sont:

  • Le nom est uniquement accessible dans la fonction et n’a pas de lien.
  • Il est initialisé lorsque la première exécution atteint la définition, pas nécessairement pendant les phases d’initialisation du programme.

La deuxième différence peut être utile pour éviter le fiasco d’ordre d’initialisation statique , où les variables globales sont accessibles avant leur initialisation. En remplaçant la variable globale par une fonction qui renvoie une référence à une variable statique locale, vous pouvez garantir qu’elle est initialisée avant que quoi que ce soit n’y accède. (Cependant, rien ne garantit qu’il ne sera pas détruit avant que quoi que ce soit ne finisse d’y accéder; vous devez toujours faire très attention si vous pensez avoir besoin d’une variable accessible globalement. Voir les commentaires pour un lien permettant de vous aider dans cette situation. )

Leur scope est différente. Une variable statique de scope globale est accessible à toute fonction du fichier, tandis que la variable de scope de fonction est accessible uniquement au sein de cette fonction.

Espérons que cet exemple aidera à comprendre la différence entre variable locale statique et variable globale.

 #include  using namespace std; static int z = 0; void method1() { static int x = 0; cout << "X : " << ++x << ", Z : " << ++z << endl; } void method2() { int y = 0; cout << "Y : " << ++y << ", Z : " << ++z << endl; } int main() { method1(); method1(); method1(); method1(); method2(); method2(); method2(); method2(); return 0; } 

sortie:

 X : 1, Z : 1 X : 2, Z : 2 X : 3, Z : 3 X : 4, Z : 4 Y : 1, Z : 5 Y : 1, Z : 6 Y : 1, Z : 7 Y : 1, Z : 8 

Son vrai nom est:

 static storage duration object. 

Les variables globales sont également des «objects de durée de stockage statique». Les principales différences par rapport aux variables globales sont les suivantes:

  • Ils ne sont initialisés qu’à la première utilisation
    Remarque: Une exception lors de la construction signifie qu’ils n’ont pas été initialisés et donc non utilisés.
    Donc, il va ré-essayer la prochaine fois que la fonction est entrée.
  • Leur visibilité est limitée par leur scope
    (ie ils ne peuvent pas être vus en dehors de la fonction)

En dehors de cela, ils sont comme d’autres “objects de durée de stockage statique”.

Remarque: comme tous les «objects de durée de stockage statique», ils sont détruits dans l’ordre inverse de leur création.

La différence principale ou la plus grave est le temps d’initialisation. Les variables statiques locales sont initialisées lors du premier appel à la fonction où elles sont déclarées. Les variables globales sont initialisées à un moment donné avant l’appel de la fonction main. Si vous avez peu de variables statiques globales, elles sont initialisées dans un ordre non spécifié, ce qui peut poser problème. c’est ce qu’on appelle le fiasco d’initialisation statique.

Dans votre premier bloc de code, x est local à la fonction foo (), ce qui signifie qu’elle est créée dans foo () et détruite à la fin de la fonction après la création de cout. Cependant, dans votre deuxième bloc, x est global, ce qui signifie que la scope de x correspond à l’ensemble du programme. Si vous vouliez sous-main votre cout pourrait << x << endl et il imprimerait cependant, dans le premier bloc il dirait x non déclaré

  1. Elles sont connues de toutes les fonctions d’un programme alors que les variables globales ne sont connues que dans un périmètre limité.
  2. Les variables statiques globales peuvent être initialisées avant le démarrage du programme, tandis que les variables statiques locales peuvent être initialisées au fur et à mesure de l’exécution.