Ca existe dans boost ?

Version imprimable

Est ce qu'il y aurais une fabrique d'objet dans boost ?

Une fabrique d'objet qui pourrais créer des objets de hiérarchie différentes, en me retournant le bon objet directement typé ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Point class Point2D : public Point class Point3D : public Point ... class Forme class Cercle : public Forme class Triangle : public Forme ... Point2D* p2D = Factory.Make ("Point2D"); Triangle* t = Factory.Make ("Triangle");
Je peut en créer une, mais une qui retournerais un void*
Bien que je pourrais utiliser le cast boost pour tester si je reçoit le bon type.

Mais j'aimerais savoir si cela existe déjà dans Boost ou pas

J'ai la solution, je l'ai codée vite fait en un peut moins d'une heure.

Je dois encore arranger un peut, pour mettre une gestion d'erreur, mais la solution est assez bonne.

J'aurais juste a coder ainsi:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Forme* pForme = fabrique.make<Forme> ("Triangle"); vector<Point*> vPoint; vector<Forme*> vForme; vPoint.push_back (fabrique.make<Point>("Point2D")); vPoint.push_back (fabrique.make<Point>("Point3D")); . . . vForme.push_back (fabrique.make<Forme> ("Cercle")); vForme.push_back (fabrique.make<Forme> ("Triangle")); . . .
Si je veux un pointeur directement sur une classe plus haut dans la hiérarchie, je dois spécifier cette classe (mais bon, c'est pas prévu pour l'utiliser de cette manière):

Code:

Point3D* p3D = fabrique.make<Point3D> ("Point3D");

Si je rajoute un élément a une hiérarchie:
Code:

1 2 3 4 5 6 7 8 9 10 11 class Ligne { . . . private: typedef FabriqueTemplate<Ligne> Fabrique; static Fabrique fabrique; }; Ligne::Fabrique Ligne::fabrique ("Ligne");
grosso modo, juste trois lignes de code à rajouter.

17/11/2008, 12h21
Alp

Faire retourner à make<T> un shared_ptr<T> ou assimilé ne serait pas un luxe à mon avis.

Sinon, il y a "flyweight_factory" quelque part dans Boost (pas encore validée officiellement) qui pourrait peut-être t'intéresser.

Par contre, attention, tu as codé une factory spécifique à tes besoins. On pourrait imaginer une factory paramétrable (comme dans Loki) grâce aux classes de traits et de politiques : on paramètrerait ainsi l'objet retourné par make<T>, le stockage des clés & co, la type de fonctions qui s'occupent de créer les objets et le type de création (création d'un objet tout neuf, clonage d'un prototype, ...), et j'en passe et des meilleures.

bon, je vais mettre ma solution toute laide (je ne l'ai pas encore rafinée, c'est du brut de ce matin après une nuit blanche

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
#include <iostream>
#include <map>
#include <string>
 
using namespace std;
 
 
class Fabrique
{
protected:
	virtual void* Make () = 0;
 
friend class FabriquePrincipale;
};
 
 
 
 
class FabriquePrincipale
{
public:
	static FabriquePrincipale& Instance ();
 
	void Add (const string& name, Fabrique* fabrique)
	{
		fabriques.insert (make_pair (name, fabrique));
	}
 
	template <typename T> T* Make (const string& name)
	{
		Iterator it = fabriques.find (name);
		if (it != fabriques.end ())
		{
			return (T*)(*it).second->Make ();
		}
		return NULL;
	}
 
private:
	 FabriquePrincipale () {}
	~FabriquePrincipale () {}
 
	typedef map<string, Fabrique*> Map;
	typedef Map::iterator          Iterator;
 
	static Map fabriques;
};
 
 
template <typename T> class FabriqueTemplate : public Fabrique
{
protected:
	void* Make () { return new T; }
 
	FabriqueTemplate (const string& name)
	{
		FabriquePrincipale::Instance ().Add (name, this);
	}
 
	friend T;
};
 
 
 
class Point
{
public:
	virtual void Print () = 0;
};
 
class Point2D : public Point
{
public:
	virtual void Print () { cout << "Point2D" << endl; }
 
private:
	typedef FabriqueTemplate<Point2D> Fabrique;
	static Fabrique fabrique;
};
 
class Point3D : public Point
{
public:
	virtual void Print () { cout << "Point3D" << endl; }
 
private:
	typedef FabriqueTemplate<Point3D> Fabrique;
	static Fabrique fabrique;
};
 
class Forme
{
public:
	virtual void Print () = 0;
};
 
class Triangle
{
public:
	virtual void Print () { cout << "Triangle" << endl; }
 
private:
	typedef FabriqueTemplate<Triangle> Fabrique;
	static Fabrique fabrique;
};
 
class Cercle
{
public:
	virtual void Print () { cout << "Cercle" << endl; }
 
private:
	typedef FabriqueTemplate<Cercle> Fabrique;
	static Fabrique fabrique;
};
 
 
 
FabriquePrincipale::Map FabriquePrincipale::fabriques;
 
 
FabriquePrincipale& FabriquePrincipale::Instance ()
{
	static FabriquePrincipale instance;
	return instance;
}
 
 
Point2D::Fabrique  Point2D::fabrique  ("Point2D");
Point3D::Fabrique  Point3D::fabrique  ("Point3D");
Cercle::Fabrique   Cercle::fabrique   ("Cercle");
Triangle::Fabrique Triangle::fabrique ("Triangle");
 
 
int main ()
{
	FabriquePrincipale& fabrique = FabriquePrincipale::Instance ();
 
 
 
 
	Point2D d2;
	Point3D d3;
 
	Cercle   c;
	Triangle t;
 
	d2.Print ();
	d3.Print ();
 
	c.Print ();
	t.Print ();
 
	string point[] = { "Point2D", "Point3D" };
	string forme[] = { "Cercle", "Triangle" };
 
	for (int i = 0; i < 2; i++)
		fabrique.Make<Point> (point[i])->Print ();
 
	for (int i = 0; i < 2; i++)
		fabrique.Make<Forme> (forme[i])->Print ();
 
 
	int i;
	cin >> i;
 
	return 0;
}

21/11/2008, 11h40
Klaim

Il n'y avait pas une lib pour les "factory" qui avait été proposée puis rejettée?

(après vérifications)

Elle a été acceptée sous conditions, et devrait donc apparaitre dans les versions futures de boost : http://lists.boost.org/boost-announce/2007/12/0161.php