[VC++6.0] Pb de déclaration d'une variable de type template singleton

Version imprimable

Bonjour à toutes et à tous !

J'ai récupéré le code source d'une application que je dois optimiser. Il y a quelques variables globales dans cette application et je souhaite mettre à profit le Design Pattern Singleton.

J'ai récupéré un code source définissant une classe template singleton (.h suivant) :
Code:

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 #ifndef _SINGLETON_H #define _SINGLETON_H template <class T> class CSingleton { public: // Renvoi l'instance unique de la classe static CSingleton* Instance() { if( !pInst ) pInst = new T; return pInst; } // Détruit l'instance unique de la classe static void Destroy() { delete pInst; pInst = NULL; } protected: // Constructeur par défaut CSingleton(); // Destructeur par défaut ~CSingleton(); private: // Donnée membre static T* pInst; // Copie interdite CSingleton(const CSingleton&); void operator=(const CSingleton&); }; // Déclaration de notre variable statique template <class T> T* CSingleton<T>::pInst = NULL; #endif
Jusque la pas de problème :), pas de problème de compilation.

Etape suivante, je souhaite créer mes propres classes dérivant de cette classe template ... hop c'est parti en faisant comme ci après (j'ai juste utilisé un .h) :
Code:

1 2 3 4 5 6 7 8 9 10 #ifndef _UN_SINGLETON_H #define _UN_SINGLETON_H class CUnSingleton : public CSingleton<CUnSingleton> { friend class CSingleton<CUnSingleton>; }; #endif
Là encore je compile et aucune erreur :)

Mon problème est le suivant : comment déclarer dans mon main une variable de type CUnSingleton ? Quand je fais :
Code:

1 2 CSingleton<CUnSingleton>* S = CSingleton<CUnSingleton>::Instance();
ça passe pas et j'ai le message d'erreur suivant :
Code:

1 2 TEMPLATE_SINGLETON.obj : error LNK2001: unresolved external symbol "protected: __thiscall CSingleton<class CUnSingleton>::CSingleton<class CUnSingleton>(void)" (??0?$CSingleton@VCUnSingleton@@@@IAE@XZ)
Est ce que quelqu'un a une idée à me proposer pour résoudre mon problème ?

D'avance merci.

23/10/2006, 16h01
Yellowmat

Information supplémentaire, le code que j'ai repris est celui de Laurent GOMILA et tiré de ses articles sur le développement d'un moteur 3D ... rendons à César ce qui lui appartient.
23/10/2006, 22h39
philippe V
pour utilise ont object derive de CSingleton tu peur essaille
Code:

1 2 CUnSingleton& singleton = CUnSingleton::Instance();
24/10/2006, 06h41
farscape
Citation:
Envoyé par philippe V

pour utilise ont object derive de CSingleton tu peur essaille

Code:

1 2 CUnSingleton& singleton = CUnSingleton::Instance();
plutôt:
Code:

1 2 CUnSingleton* psingleton = CUnSingleton::Instance();
:D

J'ai essayé ta solution Farscape mais j'obtient l'erreur.
Code:

1 2 error C2440: 'initializing' : cannot convert from 'class CSingleton<class CUnSingleton> *' to 'class CUnSingleton *'

25/10/2006, 15h35
farscape

bon bizarre ,je viens d'essayer ton code (la premiere version)
ça compil bien sous visual 6.0 et 2005
la seule difference c'est que pour des raisons de facilité de test j'ai tout mis dans le même source:
la definition du template, et l'appel à instance.
tu peux faire un essai dans ce sens ?

:D

Ca compile pour toi ? C'est bizarre ...

J'ai testé ta proposition en faisant comme suit :

Code:

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
50
51
52
53
54
55
56
57
58
59
 
#ifndef _SINGLETON_H
#define _SINGLETON_H
 
using namespace std;
 
template <class T>
class CSingleton
{
	public:
		// Renvoi l'instance unique de la classe
		static CSingleton* Instance()
		{
			cout << "Appel de la fonction Instance de CSingleton" << endl;
			if( !pInst )
			{
				cout << "Création d'un objet CSingleton" << endl;
				pInst = new T;
			}
			else
				cout << "L'objet CSingleton est déjà crée" << endl;
 
			return pInst;
		}
 
		// Détruit l'instance unique de la classe
		static void Destroy()
		{
			cout << "Destruction de l'objet CSingleton" << endl;
			delete pInst;
			pInst = NULL;
		}
 
	protected:
		// Constructeur par défaut
		CSingleton();
 
		// Destructeur par défaut
		~CSingleton();
 
	private:
		// Donnée membre
		static T* pInst;
 
		// Copie interdite
		CSingleton(const CSingleton&);
		void operator=(const CSingleton&);
};
 
// Déclaration de notre variable statique
template <class T> T* CSingleton<T>::pInst = NULL;
 
class CUnSingleton : public CSingleton<CUnSingleton>
{
	friend class CSingleton<CUnSingleton>;
};
 
CUnSingleton* psingleton = CUnSingleton::Instance();
#endif

Je n'ai maintenant plus qu'un et un seul header qui se nomme Singleton.h malheureusement j'ai toujours la même erreur.

J'ai VC++6.0 mais je ne sais pas si le service pack a été installé.

Je ne vois pas ce que je peux donner d'autre comme informations.

non en testant avec:

Code:

1
2
 
CSingleton<CUnSingleton>* S = CSingleton<CUnSingleton>::Instance();

25/10/2006, 15h51
Yellowmat

J'ai testé toutes les différentes possibilités :
* tout dans un seul fichier (définition et déclaration)
* dans des fichiers séparés, déclaration (conforme à ta proposition) dans le main

maintenant ça compile mais j'ai à nouveau l'erreur d'édition des liens :

Code:

unresolved external symbol "protected: __thiscall CSingleton<class CUnSingleton>::CSingleton<class CUnSingleton>(void)" (??0?$CSingleton@VCUnSingleton@@@@IAE@XZ)

arf ,je suis fatigué j'ai mal vu,
tu as oublié de definir le constructeur protected....
(attention au destructeur...)

Code:

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
template <class T>
class CSingleton
{
    public:
        // Renvoi l'instance unique de la classe
        static CSingleton* Instance()
        {
            if( !pInst )
                pInst = new T;
 
            return pInst;
        }
 
        // Détruit l'instance unique de la classe
        static void Destroy()
        {
            delete pInst;
            pInst = NULL;
        }
 
    protected:
        // Constructeur par défaut
        CSingleton(){}
 
        // Destructeur par défaut
        ~CSingleton();
 
    private:
        // Donnée membre
        static T* pInst;
 
        // Copie interdite
        CSingleton(const CSingleton&);
        void operator=(const CSingleton&);
};

en gras ci-dessus..
:D

25/10/2006, 16h01
Yellowmat

:lol: désolé, je n'ai pas fait attention non plus.

Au passage, j'ai définit mon destructeur comme virtuel ... ma classe template CSingleton étant destiné à être dérivée, ça se justifie non ?
25/10/2006, 16h03
Yellowmat
Avant d'oublier ...

je constate que dans le code il y a :
Code:

1 2 3 4 5 private: // Copie interdite CSingleton(const CSingleton&); void operator=(const CSingleton&);
ça ne pose pas (visiblement puisque la compilation et l'édition des liens sont OK) de ne pas proposer d'implémentation pour ces deux fonctions ?

J'ai copié collé le code et je ne m'en rend compte que maintenant.
25/10/2006, 16h09
farscape

ça ne cause pas de probleme tant que tu n'essayes pas d'utiliser le constructeur de copie ou l'operateur d'affectation...
:D
25/10/2006, 16h17
Yellowmat

OK, ça me rassure. En général quand je définit une méthode j'aime assez qu'elle ait une implémentation :lol:

Ta réponse me rassure et m'arrange car je ne voyais pas comment implémenter le constructeur de recopie et l'opérateur d'affectation sachant qu'à priori n'importe quelle classe peut hériter de ce template. De plus une telle implémentation me semblait incompatible avec la notion de Singleton.

En tout cas merci pour tout. J'essaierai d'être plus vigilant et d'ouvrir un peu plus grand mes yeux la prochaine fois.

Merci, ++