Discussion :

[laglumie]

Bonsoir,

le code suivant est un emprunt au tuto de David Come sur les pattern objet en C++.

Je voudrais créer une classe template Singleton,
et je cherche à lui fournir un opérateur de comparaison qui prendrait des entiers.

Je ne parviens pas à écrire son code template.

le code de singleton_tpl.tpp avec le nécessaire opérateur == :

Code c++ :

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <stdio.h>
#include <iostream>

using namespace std ;

template <class T> T Singleton<T>::m_i = T();

template <class T> T& Singleton<T>::instance()
{
	if(m_i == 0) // premier check
	{
		// CODE to lock myself
		lock() ;
		if(m_i == 0) // second
		{
			m_i =                                               // phase 3 de la liste
					static_cast<T*>(operator new(sizeof(T))) ;  // phase 1
			new (m_i) T;                                        // phase 2
			UUID = rand () ;
			pthread_mutex_init (&mutex, NULL) ;
		}

		if (m_i != 0)  // l'objet est bien initialisé
		{
			unlock() ; // ici on déverrouille simplement
		}              // un des threads,
    }

    return m_i; // ainsi il suffit d'appeler instance () plusieurs fois
}               // pour être sûr de déverrouiller notre thread

template <class T> void Singleton<T>::lock()
{
	pthread_mutex_lock (&mutex) ;
}

template <class T> void Singleton<T>::unlock()
{
	pthread_mutex_unlock (&mutex) ;
}

template <class T> bool Singleton<T>::operator==(int i) const
{
	if ( UUID == (reinterpret_cast<T>(i)).UUID )
	{
		return true ;
	}
	return false ;
}

Le compilateur (g++) me dit que mon reinterpret_cast est illégal.

Est-ce que je fais fausse route ?

Merci.

[jo_link_noir]

Je ne comprends pas ce que tu veux faire avec ton reinterpret_cast. Mais l'ensemble de ce code est inutile: une variable static pour instancier qu'une fois est thread-safe depuis C++11, le tout ne dépassant pas 2 lignes.

À noter aussi que le singleton est plutôt considéré comme un code-smell et une variable globale déguisée.

[laglumie]

(...) une variable static pour instancier qu'une fois est thread-safe depuis C++11, le tout ne dépassant pas 2 lignes.

Je ne connais pas C++11.
Je vais chercher à aborder C++11 ...

[laglumie]

Je ne connais pas C++11.
Je vais chercher à aborder C++11 ...

Je crois que je comprends : l'implémentation "naïve" (non template) de David Come est en fait la bonne solution. Il suffit d'une variable statique mais nous allons équiper notre classe Singleton d'un mutex fourni par la librairie standard C sous Linux, de façon à bloquer notre constructeur lors d'accès concurrents.

De ce fait, le code ne sera plus du "pur" C++, mais introduira des fonctions système Linux.
Pour l'adapter à Microsoft il suffira de faire des #if et des #include dans le code C++ en appelant les solutions équivalentes.

[jo_link_noir]

Comme je l'ai dit avant, l'initialisation d'une variable statique est déjà thread-safe, un mutex ne sert à rien !

Au passage, les mutex font partie de la bibliothèque standard depuis C++11. Il serait temps de se mettre à jour, cela fait 10 ans que les compilateurs supportent cette norme et il y en a eu 3 autres depuis.

[Bousk]

Je crois que je comprends : l'implémentation "naïve" (non template) de David Come est en fait la bonne solution. Il suffit d'une variable statique mais nous allons équiper notre classe Singleton d'un mutex fourni par la librairie standard C sous Linux, de façon à bloquer notre constructeur lors d'accès concurrents.

De ce fait, le code ne sera plus du "pur" C++, mais introduira des fonctions système Linux.
Pour l'adapter à Microsoft il suffira de faire des #if et des #include dans le code C++ en appelant les solutions équivalentes.

Ouais, pourquoi pas faire mal un truc simple après tout
Sinon on a std::mutex.

Mais ce pattern de singleton est dépassé et ne devrait jamais être utilisé.
Un pattern singleton propre c'est un objet qu'on instancie 1 fois et quand on le décide. Pas un truc qui s'initialise tout seul et disparait jamais.