Problème de conception : patron "fabrique" ?

Version imprimable

09/09/2008, 16h34
oodini

Problème de conception : patron "fabrique" ?

Hello,

En fonction du type d'un objet donné, je dois créer un autre objet d'un type donné. Il n'y a pas nécessairement une relation d'héritage entre les divers types.

Exemple :
Si j'ai un objet de type "Mary", je dois créer un objet du type "Poppins".

Je dispose du type de l'objet en question (fourni par une fonction membre), sous forme de chaîne, et peut donc l'envoyer en paramètre à une fonction.

1 - Une variante du patron "fabrique" est-elle adaptée à cela ? Je crois savoir que le concept de la fabrique repose sur des relations d'héritage entre les types.

2 - Accessoirement, est-il possible de faire statiquement l'association ?

Je précise que je n'ai encore jamais mis le nez dans les design patterns..

J'ai été voir cette page de Developpez.com, mais elle ne correspond pas tout à fait à mes besoins (clones, etc.)

Des petites idées ?

J'ai actuellement le nez dans le bouquin Design Pattern, et mon besoin se rapprocherait azssez de la "fabrique paramétrisée", sauf que je veux éviter les "if" en cascade (j'ai des dizaines de types à gérer).

J'ai l'impression que je ferais mieux de passer par un map [type]/[pointeur de fonction]. Dans ce cas, j'aimerais bien initialiser ce map de manière statique.

Merci !
09/09/2008, 17h30
Luc Hermitte

1- tu veux dire que tous les objets que tu veux pouvoir fabriquer ne dérivent pas d'un type commun ?
Soit tu définis une fabrique par hiérarchie de types liées
Soit tu renvoies un pointeur vers un boost::any ou autre type variant.

2- Tu ne pourras pas faire d'association statique, efficace (i.e. en O(1)), entre une chaine de caractères et un objet à fabriquer.
Avec des IDs, tu peux figer un truc non ouvert (cf principe open-close) à coups de switchs. Ou alors avec des types (ou des IDs) on s'en sort par méta-prog template ; mais alors quel intérêt à faire une fabrique ?

Bref, montre nous le code utilisateur que tu aimerais écrire, on te dira comment y arriver -- si c'est possible.

PS: dernièrement (pas plus d'un mois et demi), la question des fabriques est revenue dans le forum C&C++/Contribuez. D'autres solutions ont été évoquées.

Citation:

Envoyé par Luc Hermitte

1- tu veux dire que tous les objets que tu veux pouvoir fabriquer ne dérivent pas d'un type commun ?
Soit tu définis une fabrique par hiérarchie de types liées
Soit tu renvoies un pointeur vers un boost::any ou autre type variant.

Je peux faire en sorte qu'ils dérivent d'un type commun. Mais l'emploi du polymorphisme s'effectuera à un niveau intermédiaire.
Mais ce n'est pas tant là que réside mon problème (même si je note ton observation, car il n'est pas exclu que le problème se présentera à moi par la suite).

Citation:

2- Tu ne pourras pas faire d'association statique, efficace (i.e. en O(1)), entre une chaine de caractères et un objet à fabriquer.
Avec des IDs, tu peux figer un truc non ouvert (cf principe open-close) à coups de switchs. Ou alors avec des types (ou des IDs) on s'en sort par méta-prog template; mais alors quel intérêt à faire une fabrique ?

J'aimerais justement éviter les switch / if en cascade, car il y a beaucoup de types. Pour l'open/close, ce n'est pas gênant, car l'utilisation est interne à la classe.

Citation:

Envoyé par Luc Hermitte

Bref, montre nous le code utilisateur que tu aimerais écrire, on te dira comment y arriver -- si c'est possible.

J'espère que tu comprendras ce que je veux avec ce qui figure ci-dessous.
J'ai mis en italique les choses que je sais incorrectes, mais qui aident à exprimer mon idée.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Vehicle {...}; class Car {...}; class Motorbike {...}; map["vehicule"] = Vehicle; map["voiture"] = Car; map["moto"] = Motorbike; fabrique(string vehicule, param1, param2) { return new map_vehicules["voiture"](, param1, param2); } main() { Vehicle toto = fabrique("voiture", param1, param2); }
Citation:

PS: dernièrement (pas plus d'un mois et demi), la question des fabriques est revenue dans le forum C&C++/Contribuez. D'autres solutions ont été évoquées.

OK, je vais chercher ça en attendant.

09/09/2008, 18h07
Luc Hermitte

OK. Deux choses quasi impératives:
- un pseudo type commun (soit une classe véhicule), soit du boost.any en retour
- que toutes tes constructions attendent les mêmes paramètres (nombre et type)

Et là, la solution que j'avais donnée quand l'autre forum peut répondre à tes questions. Par contre ... la doc embarqué est à la rue complet.
09/09/2008, 18h18
oodini

Fais-tu référence à ce thread ?
09/09/2008, 18h25
Luc Hermitte

Oui.
09/09/2008, 20h32
HanLee

Citation:

Envoyé par Luc Hermitte

OK. Deux choses quasi impératives:
- un pseudo type commun (soit une classe véhicule), soit du boost.any en retour

Je conseillerais plutôt boost.Variant si le nombre de types possibles est fixé à l'avance.
10/09/2008, 12h28
oodini

Les types sont connus à l'avance, mais bien trop nombreux pour utiliser Boost.Variant.

Mais néanmoins merci de m'avoir fait le mettre le nez dans cette lib.
10/09/2008, 12h29
oodini

Citation:

Envoyé par Luc Hermitte

OK. Deux choses quasi impératives:
- un pseudo type commun (soit une classe véhicule), soit du boost.any en retour
- que toutes tes constructions attendent les mêmes paramètres (nombre et type)

J'ai codé un truc avec Boost::function, mais ça ne fonctionne pas quand le constructeur prend des arguments.

RDV dans la section Boost pour la suite. :-)

Et avec des classes traits et des spécialisations partielles?:

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
class Mary {};
class Poppins {};
 
class Lord {};
class Jim {};
 
template<typename T> struct TraitAssociation{};
 
template<> struct TraitAssociation<Mary>
{
   typedef Poppins* ptypeRetour;
};
template<> struct TraitAssociation<Lord>
{
   typedef Jim* ptypeRetour;
};
 
template<class T>
typename TraitAssociation<T>::ptypeRetour CreerElement(const T&);
 
template<>
TraitAssociation<Mary>::ptypeRetour CreerElement<Mary>(const Mary&)
{
   return new Poppins();
}
 
template<>
TraitAssociation<Lord>::ptypeRetour  CreerElement<Lord>(const Lord&)
{
   return new Jim();
}
 
int main()
{
   Mary oMary;
   Lord oLord;
 
   delete CreerElement(oMary);
   delete CreerElement(oLord);
 
   return 0;
}

10/09/2008, 15h21
oodini

C'est une solution, mais ça fait beaucoup de lignes de code.
Je dois gérer des dizaines de types.

Merci tout de même.

Bon, et avec des macros (je sais, c'est pas terrible les macros, mais de temps en temps) :

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
 
class Mary {};
class Poppins {};
 
class Lord {};
class Jim {};
 
template<typename T> struct TraitAssociation{};
template<class T>
typename TraitAssociation<T>::ptypeRetour CreerElement(const T&);
 
#define M_AjouterAssociation(Cle,Valeur)\
   template<> struct TraitAssociation<Cle>\
   {\
      typedef Valeur* ptypeRetour;\
   };\
   template<>\
   TraitAssociation<Cle>::ptypeRetour CreerElement<Cle>(const Cle&)\
   {\
      return new Valeur();\
   }
 
M_AjouterAssociation(Mary,Poppins)
M_AjouterAssociation(Lord,Jim)