Comment le compilateur résout-il les boucles de référence infinies?

Question

// edited by Neil Butterworth to conserve vertical space 
#include <stdio.h> 

struct A; 
struct B; 

A& GetAInstance(); 
B& GetBInstance(); 

struct A { 
    A() { 
     printf("A\n"); 
    } 
    ~A() { 
     printf("~A\n"); 
     B& b = GetBInstance(); 
    } 
}; 

struct B { 
    B() { 
     printf("B\n"); 
    } 

    ~B() { 
     printf("~B\n"); 
     A& a = GetAInstance(); 
    } 
}; 

A& GetAInstance() { 
    static A a; 
    return a; 
} 

B& GetBInstance() { 
    static B b; 
    return b; 
} 

int main() { 
    A a; 
} 

Considérons le scénario ci-dessus. Je pense que cela le résultat dans une boucle infinie de référence résultant du programme étant incapable de quitter de-initialisation statique, mais le programme couru très bien avec l'impression suivante:

A 
    ~A 
    B 
    ~B 
    A 
    ~A 

Ce qui était inattendu.

Comment un compilateur gère-t-il cette situation? Quels algorithmes utilise-t-il pour résoudre la récursion infinie? Ou ai-je mal compris quelque chose de fondamental? Est-ce, quelque part dans la norme, défini comme non défini?

Answer 1

Le compilateur stocke effectivement un bool avec chaque static pour se rappeler s'il a été initialisé.

Voici l'ordre:

intérieur principal:

• Construct A
• Destruct A
• • Construire static B

Nettoyage de statics:

• Destruct static B
• • Construire static A
  • Destruct static A

3.6.3/1 dans la norme spécifie qu'il doit travailler de cette façon, même quand un static est construit pendant le nettoyage comme dans ce cas.

Answer 2

Ce comportement est probablement dû au fait que vous utilisez des instances statiques. Le compilateur prend certainement soin de l'état des variables statiques pour éviter d'effectuer plusieurs initialisations/désinitialisations.