liste d'objets polymphes utilisant template non defini..

Version imprimable

Bonjour à tous
Il est tard et donc il se peut que ma question soit très simple.. mais j'en doute quand meme un peu :-)

j'ai une classe abstraite d'Instrument
Code:

1 2 3 4 class Instrument{ //pure virtual //.... };
une classe Portefeuille
Code:

1 2 3 4 5 class Portfolio{ protected: std::list<boost::shared_ptr<Instrument> list_; //..... };
une classe Operation
Code:

1 2 3 4 5 class Operation{ //pure virtual virtual void applyTo(Portfolio* p, date d) = 0; //.... };
des classes templates dérivées
Code:

1 2 3 4 5 template <class T> class SOperation: public Operation{ //..... void applyTo(Portfolio* p, date d); };
et une classe stgy qui consiste en gros à uneliste d'Operations et qui utilise entre autres deux méthodes
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Stgy{ //virtual std::list<boost::shared_ptr<Operation> > listOp_; void Stgy::applyTo(Portfolio* p, date d){ //... this->buildListOperation(p, ref); foreach(boost::shared_ptr<Operation> op, listOp_) op->applyTo(p, ref); } double Stgy::buildListOperation(Portfolio* p, date d){ //..... for (Portfolio::iterator it= p->begin(); it!= p->end(); ++it) addOperation(boost::shared_ptr<Operation>(new SOperation<typeid(it)>(d)); }
c'est dans cette derniere que se situe le noeud de mon problème
POur chaque element de mon portefeuille je veux rajouter une operation de type SOperation (donc template) avec pour argument de template le type de l'element du portefeuille (càd l'element de la liste polymorphique)..
Je sais qu'avec typeid on sait recuperer le type d'un element polymphq, mais ce que je ne sais pas c'est comment passer ce type comme argument d'un template...
Si qqun voit...:cry:
Tks
David

17/05/2009, 00h52
JolyLoic

Ce que tu veux n'est pas directement possible. Un paramètre template doit être connu à la compilation, ce qui n'est pas ton cas ici.

Pourquoi ne pas avoir dans fonction virtuelle dans Instrument qui retournerait une opération associée à l'instrument concret ? C'est ce qui me semble le plus simple, même si ça demande d'ajouter ce code (d'une ligne, mais quand même) dans chaque classe dérivée d'instrument.
17/05/2009, 18h27
dhoorens

Mais ce problème se poserait pour chaque Operation que j'inventerais alors => je devrais rajouter autant de lignes de code que j'invente d'Operations dans chaque Instrument... Ca fait pas très générique tout ca...:-/

En bidouillant avec le CRTP, tu peux faire quelque chose comme ça :

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
 
class Operation;
template<class T> class OperationConcrete;
 
class Instrument
{
public:
   virtual ~Instrument()=0;
   virtual Operation* CreerOperation()=0;
};
 
template<class InstrumentT>
struct InstrumentOperable : public Instrument
{
public:
   Operation* CreerOperation()
   {
      return CreerOperationConcrete<OperationConcrete>();
   }
private:
   template<template<class > class OpT>
   OpT<InstrumentT>*CreerOperationConcrete()
   {
      return new OpT<InstrumentT>();
   }
};
 
class IntrumentConcret :public InstrumentOperable<IntrumentConcret>
{
};

18/05/2009, 11h08
bacelar

Je ne suis pas un spécialiste des Design Pattern, mais moi, j'aurais implémenté ces actions avec des visiteurs.
18/05/2009, 16h38
dhoorens

Citation:

Envoyé par bacelar

Je ne suis pas un spécialiste des Design Pattern, mais moi, j'aurais implémenté ces actions avec des visiteurs.

càd?

Citation:

Envoyé par 3DArchi

En bidouillant avec le CRTP, tu peux faire quelque chose comme ça :

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
 
class Operation;
template<class T> class OperationConcrete;
 
class Instrument
{
public:
   virtual ~Instrument()=0;
   virtual Operation* CreerOperation()=0;
};
 
template<class InstrumentT>
struct InstrumentOperable : public Instrument
{
public:
   Operation* CreerOperation()
   {
      return CreerOperationConcrete<OperationConcrete>();
   }
private:
   template<template<class > class OpT>
   OpT<InstrumentT>*CreerOperationConcrete()
   {
      return new OpT<InstrumentT>();
   }
};
 
class IntrumentConcret :public InstrumentOperable<IntrumentConcret>
{
};

Merci d'avance, je vais tenter cà ce soir ou demain..
A+