Discussion :

[Fry]

Bonjour

j ai un comportement etrange avec mon implementation de l heritage d'un singleton...

voici la sortie du prog:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
 inst1 = 00354F30
 inst2 = 00000000
Ce message est affiche par concretSingleton1
 
Bizarre qu'un pointeur NULL plante pas...
Ce message est affiche par concretSingleton2
Ce message est affiche par concretSingleton1

en fait le pointeur inst2 est egale a 0 et pourtant l appel d'un fonction de inst2 s'effectue correctement

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
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
#include <iostream>
 
class abstractSingleton
{
protected:
	static abstractSingleton* instance;
	abstractSingleton(){}
	virtual ~abstractSingleton(){}
};
abstractSingleton* abstractSingleton::instance = NULL;
 
class concretSingleton1 : public abstractSingleton
{
private:
	concretSingleton1() {}
	~concretSingleton1() {}
public:
	static abstractSingleton* GetInstance()
	{
		if ( abstractSingleton::instance == NULL )		{
			abstractSingleton::instance = new concretSingleton1();
		}
		return abstractSingleton::instance;
	}
 
	void Message()
	{
		std::cout << "Ce message est affiche par concretSingleton1" << std::endl;
	}
};
 
class concretSingleton2 : public abstractSingleton
{
private:
	concretSingleton2() {}
	~concretSingleton2() {}
 
public:
	static abstractSingleton* GetInstance()
	{
		if ( abstractSingleton::instance == NULL )
		{
			abstractSingleton::instance = new concretSingleton2();
		}
		return abstractSingleton::instance;
	}
 
	void Message()
	{
		std::cout << "Ce message est affiche par concretSingleton2" << std::endl;
	}
};
 
int main()
{
	concretSingleton1* inst1 = NULL;
	concretSingleton2* inst2 = NULL;
 
	inst1 = dynamic_cast<concretSingleton1*> (concretSingleton1::GetInstance());
	inst2 = dynamic_cast<concretSingleton2*> (concretSingleton2::GetInstance());
 
	std::cout << " inst1 = " << inst1 << std::endl;
	std::cout << " inst2 = " << inst2 << std::endl;
 
	if (inst1 != NULL)		inst1->Message();
	if (inst2 != NULL) 		inst2->Message();
 
	std::cout << std::endl << "Bizarre qu'un pointeur NULL plante pas..." << std::endl;
	inst2->Message();
	inst1->Message();
 
	std::cin.ignore();
	return 0;
}

hors le test de nullité du pointeur affiche bien le seul qui doit etre instancier...

[Fry]

ben en ajoutant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
public:
	virtual void Message() = 0;

dans AbstractSingleton ca plante.... donc c bon
mais je voi pas exactement pourquoi

[Luc Hermitte]

Pas bon ton truc. Tes deux singletons partagent la même implémentation.

1- Tu démarres avec ton AbstractSingleton (as) à null.
2- Tu fais un GetInstance sur Concrete1. Cela initialise as à une valeur qui a du sens.
2.1 Tu fais un dynamic_cast sur as qui est bien un C1. as est bien un C1, tout va bien, inst1 est non null
3- Tu fais un GetInstance sur Concrte2. as est déjà non null, il reste non modifié.
3.1. Tu fais un dynamic_cast sur as qui est toujours un C1 et non un C2. Tout va mal, inst2 est null


Mais je pense que tu avais réussi à suivre de toi même jusque là.

Ensuite, Si cela ne plantait pas, c'est je crois parce que l'appel d'une fonction sur un objet null conduit à un comportement non défini. Soit, cela peut planter ou non.


Bref. Procéder de la sorte ne permet pas de définir proprement des singletons. As-tu regardé du côté d'ACE ou de Loki ?

[Fry]

Pourtant j'ai appris une partie de l'implementation dans un livre sur le C++.
En quoi la methode est mauvaise?
J'obtient bien une hierarchie de classe dont je ne peu instancier qu'une seule classe a la fois.
Enfin je pense

[Luc Hermitte]

Il faut templatiser si tu veux de l'héritage (selon le Curiously Recurrent Template Pattern). Mais cela devient franchement compliqué pour rien.

Peu importe que la classe ne soit pas structurellement instanciable plusieurs fois. Ce qui est intéressant avec les singletons, c'est d'avoir un moyen d'accéder de façon "sécurisée" et "simple" à un objet global d'un type bien précis.

Si ton bouquin de C++ propose d'hériter d'une classe non template .. des noms pour savoir quoi ne pas acheter.

Modern C++ Design contient le chapitre sur les singletons en C++ le plus intéressant qu'il m'ait été donné de lire -- ce qui ne veut pas dire qu'il n'existe pas d'autres bonnes lectures.

[Heptaeon]

Pour les singleton tu as un exemple de code sympa de Loulou et en plus bien commenté ^^.

http://loulou.developpez.com/tutorie.../partie1/#L3.4

[Fry]

C'est ce bouquin:
http://www.amazon.fr/exec/obidos/ASIN/2100073486/402-5040610-6857717
mais bon je le trouve super interssant moi.

D ailleur en declarant le pointeur en protected et en essayant d' instancier chaque classe heriter sur ce pointeur on obtient bien une seule instance pour l'ensemble de la hierarchie de classe.

Et je n'ai pas trouve d'info sur les Curiously Recurrent Template Pattern sur google...

Heptaeon: je connais

[Luc Hermitte]

Je ne le connais pas.

Sinon, le bon terme était en fait "Recurring" -> "Curiously Recurring Template Pattern". CRTP et C++ donnent aussi des entrées sous google.

D'ailleurs en declarant le pointeur en protected et en essayant d'instancier chaque classe heriter sur ce pointeur on obtient bien une seule instance pour l'ensemble de la hierarchie de classe.

Ce n'est certainement pas ce que tu veux faire. Je ne vois pas d'intérêt à avoir un seul singleton pour toute une hiérarchie. A quoi bon la hiérarchie dans ces conditions ?

[Fry]

Je voulai m'en servir pour creer une classe abstraite permettant de gerer les operation de server des socket puis de la derive en fonction des differents mode possible. Ca permet d'assurer qu'il n'y a qu'un seul server instancier en meme temp sur toute la hierarchie ( c vrai qu au final c mieux si on peut en faire plusieur ).
En fait la modelisation est encore en reflexion et j'avais plutot fait ca pour l'exercise. Mais doit bien y avoir un cas ou ca sert