Discussion :

[dhoorens]

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 :

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

1
2
3
4
class Instrument{
//pure virtual
//....
};

une classe Portefeuille

Code :

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

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

une classe Operation

Code :

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

1
2
3
4
5
class Operation{
//pure virtual
virtual void applyTo(Portfolio* p, date d) = 0;
//....
};

des classes templates dérivées

Code :

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

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 :

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
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...
Tks
David

[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.

[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...:-/

[3DArchi]

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

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
 
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>
{
};

[bacelar]

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

[dhoorens]

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

càd?

[dhoorens]

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

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
 
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+