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:
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:
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é