web-dev-qa-db-fra.com

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 Par la définition de l'objet. 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;
}
c++static
18
JAM

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 pour aider dans cette situation.)

25
Mike Seymour

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

7
Ricket

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

#include <iostream>

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
6
emon

Son vrai nom est:

static storage duration object.

Les variables globales sont également des «objets 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.
    Il essaiera de nouveau la prochaine fois que la fonction sera entrée.
  • Leur visibilité est limitée par leur portée
    (c'est-à-dire qu'ils ne peuvent pas être vus en dehors de la fonction)

En dehors de cela, ils sont comme d'autres "objets de durée de stockage statique".

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

4
Martin York

La différence principale ou la plus grave est le moment de l’initialisation. Les variables statiques locales sont initialisées lors du premier appel à la fonction où elles sont déclarées. Les globales sont initialisées à un moment donné avant l'appel de la fonction principale. 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.

2
piokuc

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 portée 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é

0
georges
  1. Elles sont connues de toutes les fonctions d’un programme alors que les variables globales Ne sont connues que de manière limitée. 
  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.
0
eric njora murigi