Résolution de l'ordre de l'initialisation:
Tout d'abord, c'est juste un travail autour de parce que vous avez des variables globales, que vous essayez de vous débarrasser de, mais n'ont tout simplement pas eu le temps encore (vous allez à se débarrasser d'eux finalement arn-vous pas :-)
class A
{
public:
// Get the globale instance abc
//
static A& getInstance_abc() // return reference.
{
static A instance_abc;
return instance_abc;
}
};
Cela permettra de garantir qu'il est initialisé lors de la première utilisation et détruit lorsque l'application se termine.
Multi Threaded Problème.
C++11 ne pouvons garantir que c'est thread-safe. mais le C++03 n'a pas officiellement garantir que la construction de la fonction statique des objets est thread-safe. Donc, techniquement, le getInstance_XXX() la méthode doit être protégée avec une section critique. Sur le côté positif de gcc a explicitement patch dans le cadre du compilateur qui garantit que chaque fonction statique de l'objet ne seront initialisés une fois, même en présence de threads.
Veuillez noter:
NE PAS utiliser la double vérification de verrouillage modèle pour essayer d'optimiser loin le verrouillage. Cela ne fonctionnera pas en C++
Problèmes De Création:
Lors de la création il n'y a pas de problèmes parce que nous garantissons qu'il est créé avant de pouvoir être utilisé.
Problèmes De Destruction:
Il y a un potentiel problème de l'accès à l'objet après qu'il a été détruit. Cela se produit uniquement si vous avez accès à l'objet de l'destructeur d'une autre variable globale (global je suis de référence pour les non locaux variable statique).
Solution assurez-vous de la force de l'ordre de destruction.
Rappelez-vous l'ordre de destruction est l'exact inverse de l'ordre de la construction. Donc, si vous accéder à l'objet de votre destructeur, vous devez garantir que l'objet n'a pas été détruit. Pour ce faire, vous devez garantir que l'objet est entièrement construit en avant de l'objet appelant est construit.
class B
{
public:
static B& getInstance_Bglob;
{
static B instance_Bglob;
return instance_Bglob;;
}
~B()
{
A::getInstance_abc().doSomthing();
// The object abc is accessed from the destructor.
// Potential problem.
// You must guarantee that abc is destroyed after this object.
// To guarantee this you must make sure it is constructed first.
// To do this just access the object from the constructor.
}
B()
{
A::getInstance_abc();
// abc is now fully constructed.
// This means it was constructed before this object.
// This means it will be destroyed after this object.
// This means it is safe to use from the destructor.
}
};
