Cómo hacer cumplir una orden de llamar a los destructores

Question

estoy tratando de obtener el derecho siguiente configuración:

una aplicación dada (con múltiples archivos fuente, unidades de compilación) tiene variables globales de tipo class A definido de muchas unidades de compilación. Estos deberían ser "administrados" por un nuevo para introducir class B (donde solo debería existir 1 instancia) en el sentido de que al crearse ellos mismos "se registran" en la clase B y en la destrucción "cerrar sesión".

Configurar las cosas para que los constructores funcionen es bastante directo. Uno puede usar:

types.h:

class B { 
    static B& Instance() { 
    static B singleton; 
    return singleton; 
    } 
    void registerA(const A& a) { 
    // whatever 
    } 
}; 


class A { 
    A() { B::Instance().registerA(this); } 
}; 

Como llegar a los destructores ¿verdad? Si se utiliza:

class A { 
    A() { B::Instance().registerA(this); } 
    ~A() { B::Instance().signoffA(this); } 
}; 

continuación, el destructor de B puede ser llamado antes de que el destructor de A. Luego, la instancia de la clase A cierra la sesión en una instancia recién creada de B.

El caso de prueba sería una configuración multi fuente de archivo con las definiciones de los casos de class A en un espacio de nombres:

file1.cc

#include "types.h" 
namespace C { 
    A a; 
} 

file2.cc

#include "types.h" 
namespace C { 
    A b; 
} 

supongo que el puede hacer tales cosa fácil con los indicadores inteligentes Boost. Sin embargo, si es posible, me gustaría evitar el uso de bibliotecas adicionales para mantener la dependencia lo más bajo posible.

Una cosa que podría ayudar: Todas las variables globales están en un espacio de nombres nombrado.

Answer 1

Creo que estás bien. Aquí es en 3.6.3 "Terminación":

Si la realización del constructor o inicialización dinámica de un objeto con una duración de almacenamiento estático se secuencia antes de la de otro, la realización del destructor de la segunda se secuencia antes de la iniciación del destructor del primero.

Suponga que tiene la siguiente configuración:

struct A; 

struct B 
{ 
    static B & get() { static B impl; return impl; } 
    void registrate(A *); 

private: 
    B() { /* complex stuff */ } 
    // ... 
}; 

struct A { A() { B::get().registrate(this); } }; 

A a1; 

Ahora lo que pase, el primer constructor de un objeto de tipo estático A llamará B::get(), cuyas secuencias de la construcción de la impl objeto estático antes de la finalización del primer A -constructor. Por la cláusula anterior, esto garantiza que el destructor del B impl -objeto está secuenciado después de todos los A -destructores.

Answer 2

La instancia B es estática, por lo que sobrevivirá cualquier instancia A creada después de que se haya creado el singleton B.