Quand les variables statiques au niveau de la fonction sont-elles allouées / initialisées?

Je suis convaincu que les variables déclarées globalement sont allouées (et initialisées, le cas échéant) au démarrage du programme.

int globalgarbage;
unsigned int anumber = 42;

Mais qu'en est-il des statiques définis dans une fonction?

void doSomething()
{
  static bool globalish = true;
  // ...
}

Quand l'espace est-il globalishalloué? Je devine quand le programme démarre. Mais est-il alors initialisé? Ou est-il initialisé lors de doSomething()son premier appel?

J'étais curieux à ce sujet, j'ai donc écrit le programme de test suivant et l'ai compilé avec g ++ version 4.1.2.

include <iostream>
#include <string>

using namespace std;

class test
{
public:
        test(const char *name)
                : _name(name)
        {
                cout << _name << " created" << endl;
        }

        ~test()
        {
                cout << _name << " destroyed" << endl;
        }

        string _name;
};

test t("global variable");

void f()
{
        static test t("static variable");

        test t2("Local variable");

        cout << "Function executed" << endl;
}


int main()
{
        test t("local to main");

        cout << "Program start" << endl;

        f();

        cout << "Program end" << endl;
        return 0;
}

Les résultats n'étaient pas ce à quoi je m'attendais. Le constructeur de l'objet statique n'a été appelé que lors du premier appel de la fonction. Voici la sortie:

global variable created
local to main created
Program start
static variable created
Local variable created
Function executed
Local variable destroyed
Program end
local to main destroyed
static variable destroyed
global variable destroyed

Quelques verbiage pertinents de C ++ Standard:

3.6.2 Initialisation d'objets non locaux [basic.start.init]

1

Le stockage pour les objets avec une durée de stockage statique ( basic.stc.static ) doit être initialisé à zéro ( dcl.init ) avant toute autre initialisation. Les objets de types POD ( basic.types ) avec une durée de stockage statique initialisée avec des expressions constantes ( expr.const ) doivent être initialisés avant toute initialisation dynamique. Les objets de la portée de l'espace de noms avec une durée de stockage statique définie dans la même unité de traduction et initialisés dynamiquement doivent être initialisés dans l'ordre dans lequel leur définition apparaît dans l'unité de traduction. [Remarque: dcl.init.aggr décrit l'ordre dans lequel les membres de l'agrégat sont initialisés. L'initialisation des objets statiques locaux est décrite dans stmt.dcl . ]

[plus de texte ci-dessous ajoutant plus de libertés pour les auteurs de compilateurs]

6.7 Déclaration de déclaration [stmt.dcl]

...

4

L'initialisation à zéro ( dcl.init ) de tous les objets locaux avec une durée de stockage statique ( basic.stc.static ) est effectuée avant toute autre initialisation. Un objet local de type POD ( basic.types ) avec une durée de stockage statique initialisée avec des expressions constantes est initialisé avant la première entrée de son bloc. Une implémentation est autorisée à effectuer une initialisation précoce d'autres objets locaux avec une durée de stockage statique dans les mêmes conditions qu'une implémentation est autorisée à initialiser statiquement un objet avec une durée de stockage statique dans la portée de l'espace de noms ( basic.start.init). Sinon, un tel objet est initialisé la première fois que le contrôle de temps passe par sa déclaration; un tel objet est considéré comme initialisé à la fin de son initialisation. Si l'initialisation se termine en lançant une exception, l'initialisation n'est pas terminée, elle sera donc tentée à nouveau la prochaine fois que le contrôle entre dans la déclaration. Si le contrôle rentre la déclaration (récursivement) pendant l'initialisation de l'objet, le comportement n'est pas défini. [ Exemple:

      int foo(int i)
      {
          static int s = foo(2*i);  // recursive call - undefined
          return i+1;
      }

- fin d'exemple ]

5

Le destructeur d'un objet local avec une durée de stockage statique sera exécuté si et seulement si la variable a été construite. [Remarque: basic.start.term décrit l'ordre dans lequel les objets locaux avec une durée de stockage statique sont détruits. ]

La mémoire de toutes les variables statiques est allouée au chargement du programme. Mais les variables statiques locales sont créées et initialisées la première fois qu'elles sont utilisées, pas au démarrage du programme. Il y a de bonnes lectures à ce sujet, et sur la statique en général, ici . En général, je pense que certains de ces problèmes dépendent de la mise en œuvre, en particulier si vous voulez savoir où en mémoire ces éléments seront situés.

Le compilateur allouera des variables statiques définies dans une fonction fooau chargement du programme, mais le compilateur ajoutera également des instructions supplémentaires (code machine) à votre fonction fooafin que la première fois qu'il soit appelé, ce code supplémentaire initialise la variable statique ( par exemple en invoquant le constructeur, le cas échéant).

@Adam: Cette injection de code dans les coulisses par le compilateur est la raison du résultat que vous avez vu.

J'essaye de tester à nouveau le code d' Adam Pierce et j'ai ajouté deux autres cas: variable statique dans la classe et type POD. Mon compilateur est g ++ 4.8.1, sous Windows OS (MinGW-32). Le résultat est une variable statique dans la classe est traitée de la même manière avec la variable globale. Son constructeur sera appelé avant d'entrer la fonction principale.

• Conclusion (pour g ++, environnement Windows):

  1. Variable globale et membre statique dans la classe : le constructeur est appelé avant d'entrer la fonction main (1) .
  2. Variable statique locale : le constructeur n'est appelé que lorsque l'exécution atteint sa déclaration à la première fois.
  3. Si la variable statique locale est de type POD , elle est également initialisée avant d'entrer la fonction principale (1) . Exemple de type POD: nombre int statique = 10;

(1) : L'état correct doit être: "avant qu'une fonction de la même unité de traduction ne soit appelée". Cependant, pour simple, comme dans l'exemple ci-dessous, alors c'est la fonction principale .

inclure <iostream>

#include < string>

using namespace std;

class test
{
public:
   test(const char *name)
            : _name(name)
    {
            cout << _name << " created" << endl;
    }

    ~test()
    {
            cout << _name << " destroyed" << endl;
    }

    string _name;
    static test t; // static member
 };
test test::t("static in class");

test t("global variable");

void f()
{
    static  test t("static variable");
    static int num = 10 ; // POD type, init before enter main function

    test t2("Local variable");
    cout << "Function executed" << endl;
}

int main()
{
    test t("local to main");
    cout << "Program start" << endl;
    f();
    cout << "Program end" << endl;
    return 0;
 }

résultat:

static in class created
global variable created
local to main created
Program start
static variable created
Local variable created
Function executed
Local variable destroyed
Program end
local to main destroyed
static variable destroyed
global variable destroyed
static in class destroyed

Quelqu'un testé dans l'environnement Linux?

Les variables statiques sont allouées à l'intérieur d'un segment de code - elles font partie de l'image exécutable et sont donc mappées dans déjà initialisées.

Les variables statiques dans la portée de la fonction sont traitées de la même manière, la portée est purement une construction au niveau du langage.

Pour cette raison, vous avez la garantie qu'une variable statique sera initialisée à 0 (sauf si vous spécifiez autre chose) plutôt qu'une valeur indéfinie.

Il existe d'autres facettes de l'initialisation dont vous pouvez tirer parti - par exemple, les segments partagés permettent à différentes instances de votre exécutable s'exécutant en même temps d'accéder aux mêmes variables statiques.

En C ++ (à portée globale), les objets statiques ont leurs constructeurs appelés dans le cadre du démarrage du programme, sous le contrôle de la bibliothèque d'exécution C. Sous Visual C ++, au moins l'ordre dans lequel les objets sont initialisés peut être contrôlé par le pragma init_seg .

Ou est-il initialisé lorsque doSomething () est appelé pour la première fois?

Oui, ça l'est. Ceci, entre autres, vous permet d'initialiser les structures de données accessibles globalement lorsque cela est approprié, par exemple à l'intérieur de blocs try / catch. Par exemple au lieu de

int foo = init(); // bad if init() throws something

int main() {
  try {
    ...
  }
  catch(...){
    ...
  }
}

tu peux écrire

int& foo() {
  static int myfoo = init();
  return myfoo;
}

et utilisez-le dans le bloc try / catch. Au premier appel, la variable sera initialisée. Ensuite, au premier et au prochain appel, sa valeur sera retournée (par référence).