Sur le local et le global variables statiques en C++

C++ Primer dit

Chaque local statique de la variable est initialisée avant de la première fois
l'exécution passe par la définition de l'objet. Local de la statique sont
pas détruite quand une fonction se termine; ils sont détruits lorsque le programme
se termine.

Sont locales variables statiques toute différente de la global variables statiques? D'autres ensuite l'emplacement où elles sont déclarées, quoi d'autre est-il 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;
}

OriginalL'auteur JAM | 2012-08-29

c++static

24

Les différences sont:
- Le nom n'est accessible au sein de la fonction, et n'a pas de lien.
- Il est initialisé la première fois l'exécution atteint la définition, pas nécessairement au cours du programme d'initialisation phases.
La deuxième différence peut être utile pour éviter les statique intialisation ordre fiasco, où les variables globales peuvent être consulté avant qu'ils ne soient initialisés. En remplaçant la variable globale avec une fonction qui renvoie une référence à une variable statique locale, vous pouvez garantir que c'est initialisée avant toute chose y accède. (Toutefois, il n'y a toujours pas de garantie qu'il ne sera pas détruit avant que les finitions accès; vous avez encore besoin de prendre le plus grand soin si vous pensez que vous avez besoin d'un accessible dans le monde de la variable. Voir les commentaires de l'un lien aider dans cette situation.)

Vous pouvez garantir l'ordre de destruction avec un peu de travail. stackoverflow.com/a/335746/14065

OriginalL'auteur Mike Seymour
6

De leur champ d'application est différent. Mondial dont l'étendue est variable statique est accessible à n'importe quelle fonction dans le fichier, tandis que la fonction d'étendue variable n'est accessible qu'à l'intérieur de cette fonction.

Oui, bien sûr. Merci
pas défini à travers la compilation de l'unité de s. Au sein d'une unité de compilation de la commande est définie comme l'ordre de déclaration.
Vous avez raison... j'ai été trop vague dans le commentaire 🙂

OriginalL'auteur Ricket

Espérons-le, cet exemple permet de comprendre la différence entre les variables local et global.

#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;
}

de 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

OriginalL'auteur emon

4

Il vrai nom est:
```
static storage duration object.
```
Variables globales sont aussi statique de la durée de stockage de l'objet. La différence majeure à partir de variables globales sont:
- Ils ne sont pas initialisés, jusqu'à la première utilisation
  
  Remarque: Une exception lors de la construction signifie qu'ils n'ont pas été initialisée et ne sont donc pas utilisés.
  
  Donc, il va re-essayer la prochaine fois que la fonction est entré.
- Leur visibilité est limitée par leur champ d'application
  
  (c'est à dire qu'ils ne peuvent pas être vus à l'extérieur de la fonction)
En dehors de ce qu'ils sont comme les autres 'statique de la durée de stockage des objets.

Remarque: Comme tous les 'statique de la durée de stockage des objets s'ils sont détruits dans l'ordre inverse de leur création.

Suis-je une erreur de lecture de la spec quand je l'ai lu aussi que la statique habitants être initialisé avec les autres de la statique et ne peut être retardé jusqu'à ce premier appel? (C++11 §6.7.4 semble avancer §3.6.2 pour certains cas, et de permettre que l')
3.7.1 Statique de la durée de stockage (Note: 6.7 décrit l'initialisation de locaux variables statiques). 6.7 Déclaration (Constante d'initialisation (3.6.2) d'un bloc-champ d'application entité statique de la durée de stockage, le cas échéant, est effectuée avant son bloc est d'abord entré. ... Sinon, une telle variable est initialisée la première fois, le contrôle passe à travers ses declarationConstant d'initialisation (3.6.2) d'un bloc-champ d'application entité statique de la durée de stockage; une telle variable est considéré comme initialisé à la fin de son initialisation.)

OriginalL'auteur Martin York
2

La principale ou la plus sérieuse différence est le temps de l'initialisation. Statique locale variables sont initialisées sur le premier appel à la fonction où elles sont déclarées. Les globales sont initialisées à un certain point dans le temps avant l'appel à la fonction principale, si vous avez quelques globale des variables statiques, ils sont initialisée dans un ordre non spécifié, qui peut causer des problèmes; cela s'appelle l'initialisation statique fiasco.

OriginalL'auteur piokuc
0

Dans votre premier bloc de code, x est local à la foo() fonction qui signifie qu'il est créé dans foo() est détruit à la fin de la fonction après avoir cout. Cependant, dans votre deuxième bloc x est global, ce qui signifie que le champ d'application de x est l'ensemble du programme. Si vous voulais en vertu de l'int main votre pourrait cout << x << endl et il affiche toutefois, dans le premier bloc, il serait de dire que x n'est pas déclaré

OriginalL'auteur georges
0
1. Ils sont connus pour toutes les fonctions dans un programme, tandis que global
  les variables ne sont connus que dans un périmètre limité.
2. Globale statique des variables peuvent être initialisées avant le début du programme tandis que les variables statiques peuvent être initialisés au moment de l'exécution atteint point.
OriginalL'auteur eric njora murigi

Vous devez vous connecter pour publier un commentaire.