C++ Initialisierung von statischen Variablen (noch einmal)

Question

Wenn ich zwei statische Variablen in verschiedenen Kompilierungseinheiten habe, dann ist ihre Initialisierungsreihenfolge nicht definiert. Diese Lektion ist gut gelernt.

Die Frage, die ich habe: sind alle statischen Variablen bereits zugewiesen, wenn der erste initialisiert wird. Mit anderen Worten:

static A global_a; // in compilation unit 1 
static B global_b; // in compilation unit 2 

struct A { 
    A() { b_ptr = &global_b; } 
    B *b_ptr; 

    void f() { b_ptr->do_something(); } 
} 

int main() { 
    global_a.f(); 
} 

Wird Punkt auf einen gültigen Teil des Speichers B_PTR, wobei B zugeordnet ist, und zum Zeitpunkt der Ausführung der Hauptfunktion initialisiert? Auf allen Plattformen?

Längere Geschichte:

Die Übersetzungseinheit 1 ist Qt-Bibliothek. Der andere ist meine Anwendung. Ich habe paar QObject abgeleitete Klassen, die ich in der Lage sein muss, durch den Klassennamen String zu instantiieren. Dazu kam ich mit einer Templat-Factory-Klasse bis:

class AbstractFactory { 
public: 
    virtual QObject *create() = 0; 
    static QMap<const QMetaObject *, AbstractFactory *> m_Map; 
} 
QMap<const QMetaObject *, AbstractFactory *> AbstractFactory::m_Map; //in .cpp 

template <class T> 
class ConcreteFactory: public AbstractFactory { 
public: 
    ConcreteFactory() { AbstractFactory::m_Map[&T::staticMetaObject] = this; } 
    QObject *create() { return new T(); } 
} 

#define FACTORY(TYPE) static ConcreteFactory <TYPE> m_Factory; 

Dann füge ich dieses Makro auf jeder QObject Unterklasse Definition:

class Subclass : public QObject { 
    Q_OBJECT; 
    FACTORY(Subclass); 
} 

Endlich kann ich eine Klasse durch den Typnamen instanziiert:

QObject *create(const QString &type) { 
    foreach (const QMetaObect *meta, AbstractFactory::m_Map.keys() { 
     if (meta->className() == type) { 
      return AbstractFactory::m_Map[meta]->create(); 
     } 
    } 
    return 0; 
} 

So erhält die Klasse eine statische QMetaObject Instanz: Subclass::staticMetaObject aus der Qt-Bibliothek - es wird automatisch generiert in Q_OBJECT Makro denke ich. Und dann erstellt das FACTORY Makro eine statische ConcreteFactory<Subclass> Instanz. ConcreteFactory versucht in seinem Konstruktor, auf Subclass :: staticMetaObject zu verweisen.

Und ich war ziemlich glücklich mit dieser Implementierung auf Linux (gcc), bis ich es mit Visual Studio 2008 kompilierte. Aus irgendeinem Grund war AbstractFactory :: m_Map in der Laufzeit leer, und der Debugger würde nicht mit dem Factory-Konstruktor brechen .

Hier kommt der Geruch von statischen Variablen, die auf andere statische Variablen verweisen.

Wie kann ich diesen Code optimieren, um all diese Fallen zu vermeiden?

Answer 1

Ja, der Standard erlaubt dies.

Es gibt eine Reihe von Absätzen in Abschnitt [basic.life] die

eines Objekts Vor der Lebensdauer beginnen hat begonnen, aber nach der Lagerung der das Objekt wird besetzen hat zugeteilt oder nach die Lebensdauer eines Objekts wurde beendet und vor dem Speicher, den das Objekt belegt hat, wiederverwendet oder freigegeben, jeder Zeiger, der verweist auf den Speicherort, wo der obje ct wird oder wurde möglicherweise verwendet werden, aber nur in begrenztem Umfang.

und es gibt eine Fußnote, die darauf hinweist, dass speziell auf Ihre Situation

Zum Beispiel, vor dem Aufbau eines globalen Objekts von nicht-POD-Klasse Typ

Answer 2

Ja. Alle befinden sich in .data Abschnitt, die auf einmal zugeordnet ist (und es ist kein Heap).

Anders ausgedrückt: Wenn Sie in der Lage sind, seine Adresse zu nehmen, dann ist es OK, weil es sich sicher nicht ändern wird.

Answer 3

Kurze Antwort: Es sollte funktionieren, wie Sie es codiert haben. Siehe Ben Voigt

Lange Antwort:

etwas tun:
Anstatt lassen Sie den Compiler entscheiden, wann Globals erstellt werden, erstellen Sie sie über statische Methoden (mit statischer Funktion Variablen). Dies bedeutet, dass sie bei der ersten Verwendung deterministisch erstellt werden (und in umgekehrter Reihenfolge der Erstellung zerstört werden).

Auch wenn ein globaler verwendet einen anderen während seiner Konstruktion mit dieser Methode garantiert, dass sie in der Reihenfolge erstellt werden, die erforderlich sind und somit für die Verwendung durch den anderen zur Verfügung stehen (achten Sie auf Schleifen).

struct A 
{ 
    // Rather than an explicit global use 
    // a static method thus creation of the value is on first use 
    // and not at all if you don't want it. 
    static A& getGlobalA() 
    { 
     static A instance; // created on first use (destroyed on application exit) 
    // ^^^^^^ Note the use of static here. 
     return instance; // return a reference. 
    } 
    private: 
    A() 
     :b_ref(B::getGlobalB())  // Do the same for B 
    {}        // If B has not been created it will be 
            // created by this call, thus guaranteeing 
            // it is available for use by this object 
    } 
    B& b_ref; 
    public: 
    void f() { b_ref.do_something(); } 
}; 

int main() { 
    a::getGlobalA().f(); 
} 

Obwohl ein Wort der Warnung.

Globale sind eine Anzeige von schlechtem Design.

Globals, die auf andere Globals angewiesen sind, ist ein anderer Code Geruch (vor allem während der Konstruktion/Zerstörung).

Answer 4

Wenn B einen Konstruktor hat, wie A, dann ist die Reihenfolge, in der sie aufgerufen werden, undefiniert. Dein Code funktioniert nur, wenn du Glück hast. Wenn B jedoch keinen Code benötigt, um es zu initialisieren, funktioniert Ihr Code. Es ist nicht implementierungsdefiniert.

Answer 5

Ah gilt, aber die Idee, dass statische Variablen "nicht initialisiert" sind, ist ziemlich falsch. Sie werden immer initialisiert, nur nicht unbedingt mit Ihrem Initialisierer. Insbesondere werden alle statischen Variablen vor jeder anderen Initialisierung mit dem Wert Null erzeugt. Für Klassenobjekte sind die Mitglieder Null. Daher ist global_a.b_ptr oben immer ein gültiger Zeiger, anfänglich NULL und später & global_b. Der Effekt davon ist, dass die Verwendung von nicht-Zeiger nicht spezifiziert ist, nicht undefiniert, insbesondere wird dieser Code genau definiert (in C):

// unit 1 
int a = b + 1; 

// unit 2 
int b = a + 1; 

main ... printf("%d\n", a + b); // 3 for sure 

Die Null Initialisierung Garantie wird mit diesem Muster verwendet:

int get_x() { 
    static int init; 
    static int x; 
    if(init) return x; 
    else { x = some_calc(); init = 1; return x; } 
} 

, die entweder eine Nichtrückgabe aufgrund unendlicher Rekursion oder korrekt initialisierten Wert gewährleistet.