Wann werden statische Variablen auf Funktionsebene zugewiesen / initialisiert?

Ich bin ziemlich sicher, dass global deklarierte Variablen beim Programmstart zugewiesen (und gegebenenfalls initialisiert) werden.

int globalgarbage;
unsigned int anumber = 42;

Aber was ist mit statischen, die innerhalb einer Funktion definiert sind?

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

Wann ist der Platz globalishzugeteilt? Ich vermute, wann das Programm startet. Aber wird es dann auch initialisiert? Oder wird es initialisiert, wenn doSomething()es zum ersten Mal aufgerufen wird?

Ich war neugierig und schrieb das folgende Testprogramm und kompilierte es mit 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;
}

Die Ergebnisse waren nicht das, was ich erwartet hatte. Der Konstruktor für das statische Objekt wurde erst beim ersten Aufruf der Funktion aufgerufen. Hier ist die Ausgabe:

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

Einige relevante Wörter aus C ++ Standard:

3.6.2 Initialisierung nicht lokaler Objekte [basic.start.init]

1

Der Speicher für Objekte mit statischer Speicherdauer ( basic.stc.static ) muss vor jeder anderen Initialisierung auf Null initialisiert werden ( dcl.init ). Objekte von POD-Typen ( basic.types ) mit statischer Speicherdauer, die mit konstanten Ausdrücken ( expr.const ) initialisiert wurden, müssen initialisiert werden, bevor eine dynamische Initialisierung stattfindet. Objekte des Namespace-Bereichs mit statischer Speicherdauer, die in derselben Übersetzungseinheit definiert und dynamisch initialisiert sind, werden in der Reihenfolge initialisiert, in der ihre Definition in der Übersetzungseinheit angezeigt wird. [Hinweis: dcl.init.aggr beschreibt die Reihenfolge, in der aggregierte Mitglieder initialisiert werden. Die Initialisierung lokaler statischer Objekte wird in stmt.dcl beschrieben . ]]

[mehr Text unten, der mehr Freiheiten für Compiler-Autoren hinzufügt]

6.7 Deklarationserklärung [stmt.dcl]

...

4

Die Nullinitialisierung ( dcl.init ) aller lokalen Objekte mit statischer Speicherdauer ( basic.stc.static ) wird durchgeführt, bevor eine andere Initialisierung stattfindet. Ein lokales Objekt vom Typ POD ( basic.types ) mit statischer Speicherdauer, das mit konstanten Ausdrücken initialisiert wurde, wird initialisiert, bevor sein Block zum ersten Mal eingegeben wird. Eine Implementierung kann eine frühe Initialisierung anderer lokaler Objekte mit statischer Speicherdauer unter denselben Bedingungen durchführen, unter denen eine Implementierung ein Objekt mit statischer Speicherdauer im Namespace-Bereich ( basic.start.init) statisch initialisieren darf). Andernfalls wird ein solches Objekt initialisiert, wenn die Steuerung zum ersten Mal ihre Deklaration durchläuft. Ein solches Objekt gilt nach Abschluss seiner Initialisierung als initialisiert. Wenn die Initialisierung durch Auslösen einer Ausnahme beendet wird, ist die Initialisierung nicht abgeschlossen, sodass sie beim nächsten Eingeben der Steuerung in die Deklaration erneut versucht wird. Wenn die Steuerung die Deklaration (rekursiv) erneut eingibt, während das Objekt initialisiert wird, ist das Verhalten undefiniert. [ Beispiel:

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

- Beispiel beenden ]

5

Der Destruktor für ein lokales Objekt mit statischer Speicherdauer wird genau dann ausgeführt, wenn die Variable erstellt wurde. [Hinweis: basic.start.term beschreibt die Reihenfolge, in der lokale Objekte mit statischer Speicherdauer zerstört werden. ]]

Der Speicher für alle statischen Variablen wird beim Laden des Programms zugewiesen. Lokale statische Variablen werden jedoch bei der ersten Verwendung erstellt und initialisiert, nicht beim Programmstart. Es gibt einige gute Lektüre über das, und Statik in der Regel hier . Im Allgemeinen denke ich, dass einige dieser Probleme von der Implementierung abhängen, insbesondere wenn Sie wissen möchten, wo sich dieses Material im Speicher befindet.

Der Compiler weist statische Variablen zu, die in einer Funktion foobeim Laden des Programms definiert sind. Der Compiler fügt Ihrer Funktion jedoch auch einige zusätzliche Anweisungen (Maschinencode) hinzu, foosodass dieser zusätzliche Code beim ersten Aufruf die statische Variable initialisiert ( zB Aufrufen des Konstruktors, falls zutreffend).

@Adam: Diese Code-Injektion hinter den Kulissen durch den Compiler ist der Grund für das Ergebnis, das Sie gesehen haben.

Ich versuche erneut, Code von Adam Pierce zu testen, und füge zwei weitere Fälle hinzu: statische Variable in Klasse und POD-Typ. Mein Compiler ist g ++ 4.8.1 unter Windows (MinGW-32). Das Ergebnis ist eine statische Variable in der Klasse, die mit einer globalen Variablen gleich behandelt wird. Sein Konstruktor wird vor der Eingabe der Hauptfunktion aufgerufen.

• Schlussfolgerung (für g ++, Windows-Umgebung):

  1. Globaler Variable und statisches Element in der Klasse : Konstruktor wird vor dem Teilnehmer Hauptfunktion (1) .
  2. Lokale statische Variable : Der Konstruktor wird nur aufgerufen, wenn die Ausführung zum ersten Mal ihre Deklaration erreicht.
  3. Wenn lokale statische Variable POD - Typ ist , dann wird es auch vor initialisiert eingeben Hauptfunktion (1) . Beispiel für POD-Typ: static int number = 10;

(1) : Der korrekte Zustand sollte lauten: "Bevor eine Funktion derselben Übersetzungseinheit aufgerufen wird". Für einfache, wie im folgenden Beispiel, ist es jedoch die Hauptfunktion.

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

Ergebnis:

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

Hat jemand in Linux env getestet?

Statische Variablen werden innerhalb eines Codesegments zugewiesen - sie sind Teil des ausführbaren Images und werden daher bereits initialisiert zugeordnet.

Statische Variablen innerhalb des Funktionsumfangs werden gleich behandelt, das Scoping ist lediglich ein Konstrukt auf Sprachebene.

Aus diesem Grund wird Ihnen garantiert, dass eine statische Variable auf 0 initialisiert wird (sofern Sie nichts anderes angeben) und nicht auf einen undefinierten Wert.

Die Initialisierung bietet noch einige andere Aspekte, die Sie nutzen können. Beispielsweise ermöglichen gemeinsam genutzte Segmente, dass verschiedene Instanzen Ihrer ausführbaren Datei gleichzeitig auf dieselben statischen Variablen zugreifen.

In C ++ (mit globalem Gültigkeitsbereich) werden statische Objekte als Teil des Programmstarts unter der Kontrolle der C-Laufzeitbibliothek aufgerufen. Unter Visual C ++ kann mindestens die Reihenfolge, in der Objekte initialisiert werden, durch das Pragma init_seg gesteuert werden .

Oder wird es initialisiert, wenn doSomething () zum ersten Mal aufgerufen wird?

Ja, so ist es. Auf diese Weise können Sie unter anderem Datenstrukturen mit globalem Zugriff initialisieren, wenn dies angemessen ist, z. B. innerhalb von Try / Catch-Blöcken. ZB statt

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

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

Du kannst schreiben

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

und verwenden Sie es im try / catch-Block. Beim ersten Aufruf wird die Variable initialisiert. Beim ersten und nächsten Aufruf wird dann sein Wert zurückgegeben (als Referenz).