Discussion :

[tut]

Salut !
j'ai implémenté un pattern factory, qui construit une classe à partir d'un CString (chaîne de caractères MFC).
Ma classe factory utilise un objet std::Map<CString> qui associe des CString avec des fonctions statiques qui ont pour rôle de faire un new sur leur propre constructeur.

Avec du code (de mémoire), ça donne :

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
 
class Frame
{
   // Classe de base de toutes les classes dans le std::map<>
};
 
class FrameA:public Frame
{
   static Frame* constructor() { return new FrameA(); }
};
 
class FrameB:public Frame
{
   static Frame* constructor() { return new FrameB(); }
};
 
class FrameAA:public FrameA
{
   static Frame* constructor() { return new FrameAA(); }
};
 
// --- Quelque part, ailleurs...  --- //
// Remplissage de la map
std::map<CString, Frame*(constructor*) > MonMap;
MonMap["evChose"] = FrameA::constructor;
MonMap["evBidule"] = FrameB::constructor;
MonMap["evMachin"] = FrameAA::constructor;
 
// et encore plus loin, utilisation de la map 
Frame* pFrame = MonMap[UneVariableDeTypeCString]();
// pFrame pointe sur un FrameA, ou FrameB ou FrameAA, etc...

Bon, je sais, c'est bourré d'erreurs, mais j'ai tapé ce code de mémoire, c'est juste pour vous exposer le principe.
Avec le vrai code, ça marche bien, mais j'aimerai aller plus loin...

Mais tout d'abord, quelques questions :
- est-ce qu'il éxiste des implémentations complètes de référence des design pattern GOF en C++ ?
- est-ce que ma méthode a de gros inconvénients ?

Pour aller plus loin, j'aimerai rendre le CString static à la classe, pour pouvoir remplir mon map comme ceci :

Code :

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

1
2
3
4
 
MonMap[FrameA::m_CStrCle] = FrameA::constructor;
MonMap[FrameB::m_CStrCle] = FrameB::constructor;
MonMap[FrameAA::m_CStrCle] = FrameAA::constructor;

et puis comme cette clé est utilisé dans d'autres map, autant le rendre attribut static const pour chacunes des classes héritant de Frame.

et là... je me dis que c'est moche, parce que ça ressemble à du code factorisable, qui n'est pas factorisé.
Pour info, dans le vrai logiciel, je n'ai pas trois classes qui héritent de Frame, mais 82....
Donc la question cruciale, et objet de ce long post est :

n'éxisterait-il pas un moyen de créer une liste de classes afin de pouvoir remplir mon Map de façon plus élégante que ce qui est présenté au-dessus ?

[Médinoc]

C++ COM très simplifié

Code C++ COM très simplifié :

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
 
//On va dire que Object est la classe objet de base (au lieu de Frame),
//Et que Factory est la classe factory de base
 
class FrameA : public Object
{
public:
	FrameA();
};
 
class FrameAClass : public Factory
{
public:
	Object * CreateInstance();
};
 
class FrameB : public Object
{
public:
	FrameB();
};
 
class FrameBClass : public Factory
{
public:
	Object * CreateInstance();
};
 
 
Factory * GetFactory(string className)
{
//On peut aussi faire ça avec UN SEUL objet (global) de chaque type et une map.
//Je crois que tclcl fait comme ça (sous COM, ça foirerait à cause des delete).
//L'avantage, c'est qu'on pourrait utiliser une simple CMapStringToPtr
//Et définir les factories en tant que foncteurs
 
if(className=="FrameA")
	return new FrameAClass;
else if(className=="FrameB");
	return new FrameBClass;
return NULL;
}
 
//une fonction wrapper
Object * CreateObject(string className)
{
Factory * theFactory = GetFactory(className);
return (theFactory ? theFactory->CreateInstance() : NULL);
}

Là, en utilisant la variante décrite en commentaire dans GetFactory, tu peux te faire un ensemble de foncteurs "Créateurs d'objets" dont le constructeur peut les ajouter à une map globale (c'est ce que fait tclcl).

[Médinoc]

La variante:
Et on peut améliorer en faisant un constructeur qui "enregistre" l'objet dans la classe Factory. Le constructeur de FrameAClass devra appeler le constructeur parent avec son nom en paramètre.

Code C++ Factory inspiré de tclcl (NON-TESTÉ!) :

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 Factory
{
protected:
	Factory(string className);
public:
	static Factory * GetFactory(string className);
	virtual Object * CreateInstance() const = 0;
private:
	static CMapStringToPtr theMap;
};
 
Factory::Factory(string className)
{
theMap[className] = this;
}
 
//[static]
Factory * Factory::GetFactory(string className)
{
return static_cast< Factory * >(theMap[className]);
}

Code C++ Factory inspiré de tclcl (NON-TESTÉ!) :

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
class FrameA : public Object
{
public:
	FrameA();
};
 
class FrameAClass : public Factory
{
public:
	FrameAClass();
	Object * CreateInstance() const;
};
 
 
FrameA::FrameA()
{
}
 
 
FrameAClass theFrameAClass;
 
FrameAClass::FrameAClass()
 : Factory("FrameA")
{
}
 
 
Object * FrameAClass::CreateInstance() const
{
return new FrameA;
}

[Médinoc]

(wow, triple post)

Au passage, cette "variante" répond à ta question: Elle permet de remplir "proprement" la map, et ce dès l'initialisation du programme...

[Laurent Gomila]

Une première factorisation serait dans un premier temps de raccourcir un peu le code d'enregistrement pour un nouveau type :

Code :

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

1
2
3
4
5
6
7
8
9
template <typename T>
void RegisterType()
{
    MonMap[T::m_CStrCle] = &T::constructor;
}
 
RegisterType<FrameA>();
RegisterType<FrameB>();
...

n'éxisterait-il pas un moyen de créer une liste de classes afin de pouvoir remplir mon Map de façon plus élégante que ce qui est présenté au-dessus ?

Avec un gros morceau de meta-programmation sans doute, mais je ne pense pas que ça ait un quelconque intérêt. Entre écrire une liste de types séparés par des virgules, ou une série d'appels à RegisterType, il faut de toute façon se taper un bout de code pour chaque classe à enregistrer.

[Luc Hermitte]

Concernant les implémentations des DP du GoF, c'est quelque chose de difficile à généraliser pour tous les DPs. Toutes fois, je crois bien que le boulot d'Andrei Alexandrescu est ce qu'il y a de plus poussé. Donc, cf son bouquin Modern C++ Design publié chez Adisson-Wesley, et Loki la bibliothèque qui en découle.

Concernant, l'implémentation d'une factory. Je m'étais amusé à cela il y a quelques temps. J'avais pris la factory d'Andrei comme base de départ , et l'avais étendue avec des idées prises dans un vieil article, du feu C-Report, sur les "pluggable factories".
Le résultat est sur mon site code, exemples.
Ce doit être implémenté à 80% (il manque des créateurs, dont ceux pour les flyweight factories), et la doc est complètement à la rue. Enfin, toujours est-il cela devrait pouvoir te donner des idées relatives à l'implémentation d'une factory.

[tut]

ok,
merci pour vos réponses !