Discussion :

[rooger]

Bonjour,

Désolé pour l'intitulé du message qui n'est pas des plus précis, mais je n'ai pas mieux

Voila mon problème :
je dispose d'une hiérarchie de classe telle que :
la classe de base (notons la BaseClass) n'est pas templatée.
Je dispose aussi de classes filles qui elles sont templatées (sur une dizaine de types différents possibles)
Ces classes filles possèdent une méthode non templatée que ne possède pas la classe "BaseClass".

Dans le concret, je dispose d'un vector instancié sur la BaseClass mais contenant à l'execution les classes filles templatées sur différents types.

La question est simplement comment appeler la fonction définie dans les classes filles? Jusqu'a présent la seule solution que je vois est une suite de dynamic_cast sur tous les templates possibles mais ce n'est pas tres joli...

J'aimerais donc un truc du genre:

Code :

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

1
2
3
 
vector < BaseClass* > toto;
dynamic_cast <ClasseFille <> > (toto[i]) -> methodePropreAuxFilles()

Au lieu de :

Code :

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

1
2
3
4
5
6
7
8
 
vector < BaseClass* > toto;
if (ClasseFille <template1> * cf = dynamic_cast <ClasseFille <template1> > (toto[i]))
        cf->methodePropreAuxFilles();
else if (ClasseFille <template2> * cf = dynamic_cast <ClasseFille <template2> > (toto[i]))
        cf->methodePropreAuxFilles();
....
....

J'espere que la question n'a pas déjà été posée (je ne crois pas),
Merci beaucoup d'avance !

[koala01]

Salut,

Tu pourrais envisager le pattern "chain of responsabilities"...

Cela ne te dispensera pas forcément des dynamic_cast, mais, au moins, cela permettra d'avoir un code plus souple et plus compact

L'idée est de partir sur un code proche de

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
32
33
34
35
36
37
38
39
40
41
42
43
44
class CORBase
{
    public:
        CORBase(CORBase* n):n(n){}
        virtual ~CORBase(){}
        virtual void traverse(BaseClass* b)
        {
            if(n)
                n->traverse(b);
        }
    private:
        CORBase* n;
}
class Derived1 : public CORBase
{
    public:
         Derived1(CORBase* n):CORBase(n){}
         virtual ~Derived1(){}
         virtual void traverse(BaseClass* b)
         {
              ClasseFille< type>* modif = dynamic_cast< ClasseFille<type>* >(b);
              if(!modif)
                  base::traverse(b);
              else
                  modif->methodePropre(/* arguments éventuels */);
         }
}
 
class Derived2 : public CORBase
{
    public:
         Derived2(CORBase* n):CORBase(n){}
         virtual ~Derived2(){}
         virtual void traverse(BaseClass* b)
         {
              AutreClasseFille< type>* modif = 
                                      dynamic_cast< AutreClasseFille<type>* >(b);
              if(!modif)
                  base::traverse(b);
              else
                  modif->methodePropre(/* arguments éventuels */);
         }
}
/* autant de DerivedN que nécessaire */

et tu travaillerais sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void foo(const Vector<BaseClass*>& tab)
{
    /* créons la chaine de responsabilité (aurait pu être un membre de classe)
     */
    DerivedN dN(NULL);
    Derifed2 d2(&dn);
    Derived1 d1(&d2);
    /* et parcourons le tableau en invoquant la chaine de responsabilité
     * sur chacun des éléments
     */
    for(size_t i=0;i<tab.size();++i)
        d1.traverse(tab[i]);
}

Bien sur, l'idéal resterait quand même de fournir une méthode - fusse-t-elle virtuelle pure - à la classe mère qui permette de disposer du polymorphisme

[JolyLoic]

Bien sur, l'idéal resterait quand même de fournir une méthode - fusse-t-elle virtuelle pure - à la classe mère qui permette de disposer du polymorphisme

Ou à une classe intermédiaire entre la mère et les filles dont le seul rôle serait d'ajouter cette fonction.

[koala01]

Ou à une classe intermédiaire entre la mère et les filles dont le seul rôle serait d'ajouter cette fonction.

De fait... Même si c'est fort proche, la solution est peut être d'ailleurs meilleure s'il s'avère sémantiquement incorrect de dire que la classe mère est capable de fournir le comportement correspondant à la méthode à ajouter

[rooger]

Merci beaucoup pour ces réponses,

Ou à une classe intermédiaire entre la mère et les filles dont le seul rôle serait d'ajouter cette fonction.

C'eût été trop beau, mais je dois dans la mesure du possible éviter de modifier le schéma d'héritage...

A bientot! (enfin pas trop parce que ce sera synonyme de problème )

[loufoque]

dynamic_cast <ClasseFille <> > (toto[i]) -> methodePropreAuxFilles()

Tu peux aisément faire ce genre de chose si tu restreins le type possible de toto[i] a un ensemble fini de possiblités.

Tu peux alors faire un visiteur de ce type-là :

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
struct visitor
{
    typedef void result_type;
 
    template<typename T>
    void operator()(ClasseFille<T>& o) const
    {
        o.methodePropreAuxFilles();
    }
 
    void operator()(AutreClasseFille) const
    {
        ...
    }
 
     ...
};