Bonjour à tous,

Je souhaite créer une classe singleton avec un comportement un peu diffèrent du singleton classique. L'idée est qu'une instance de cette classe puisse être créée n'importe où et n'importe quand dans mon programme, puis éventuellement détruite et recréée ailleurs. Un objet de ce type se manipule comme n'importe quel autre objet (constructeur public,...), mais une tentative de création alors qu'une instance est déjà en cours lèverait une exception. Pour l'instant je suis parti sur une petite classe utilisée en variable static dans mon singleton servant à tester l'existence d'une instance:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
template< class T>
class DynamicSingleton
{
	T * m_instance;
 
public:
 
	DynamicSingleton()
		:m_instance(NULL)
	{}
 
	void NewInstance(T * instance)
	{
		if(m_instance)
			throw std::exception("An object of this type is already available");
 
		m_instance = instance;
	}
 
	void DestroyInstance()
	{
		m_instance = NULL;
	}
 
	T * Instance()
	{
		return m_instance;
	}
};
et ma classe singleton:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class MonSingleton
{
	static DynamicSingleton<MonSingleton> m_singleton;
 
public:
 
	MonSingleton()
	{
		m_singleton.NewInstance(this);
	}
 
	~MonSingleton()
	{
		m_singleton.DestroyInstance();
	}
 
	static MonSingleton * Instance()
	{
		return m_singleton.Instance();
	}
};
Du coup je me pose la question: s'agit-il d'un système bien foireux? Une énorme erreur en cours d'exécution me pend-elle au nez ? Et surtout, avez vous une idée pour faire ça proprement?