Comment garantir la bonne initialisation des variables globales en C avec dépendances ?

Ordre global d'initialisation en C : exploration des dépendances

En C, les variables globales au sein d'une unité de traduction sont généralement initialisées dans l'ordre dans lequel elles sont déclarées. Cependant, une confusion peut survenir lors de l'examen de l'ordre d'initialisation sur plusieurs unités de traduction.

Scénario de problème initial

Considérez le code suivant :

<code class="cpp">struct Foo {
    Foo() { printf("Foo::Foo()\n"); }
    void add() { printf("Foo::add()\n"); }
    static int addToGlobal() {
        globalFoo.add();
        return 0;
    }
};

Foo globalFoo;

int dummy = Foo::addToGlobal();

int main() { printf("main()\n"); return 0; }</code>

Avec ce code, le résultat attendu est :

Foo::Foo()
Foo::addToGlobal() START
Foo::add()
Foo::addToGlobal() END
main()

Cependant, l'échange de la déclaration et de l'initialisation de dummy et globalFoo donne un résultat différent :

Foo::addToGlobal() START
Foo::add()
Foo::addToGlobal() END
Foo::Foo()
main()

Ordre d'initialisation et dépendances

Ce comportement suggère que l'ordre d'initialisation des variables globales ignore les dépendances. Dans ce cas, l'appel à Foo::addToGlobal() tente d'accéder à une méthode de Foo avant que son constructeur n'ait été appelé.

Solution : garantir une initialisation correcte

Pour garantir que le constructeur de Foo est appelé avant l'initialisation de dummy, nous pouvons définir globalFoo avant dummy dans la même unité de traduction. Cela garantit que globalFoo sera initialisé en premier, permettant à addToGlobal() d'accéder avec succès à ses méthodes.

Solution alternative : Static Initialization Guard

Alternativement, nous pouvons introduire un static Initialization Guard

<code class="cpp">static Foo* pFoo = nullptr;

if (pFoo == nullptr) {
    pFoo = &globalFoo;
}

pFoo->add();</code>

Alternativement, nous pouvons introduire un static garde d'initialisation dans Foo::addToGlobal():

Cette vérification garantit que le pointeur pFoo est initialisé sur globalFoo avant d'accéder à ses méthodes, empêchant efficacement l'utilisation prématurée de globalFoo.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!