Discussion :

[coda_blank]

Mettons que je dispose d'une classe de base et de deux classes dérivées
La classe de base possède une méthode execute et chacune des classes dérivées offre une version différente de cette méthode avec des paramètres différents
Impossible de surcharger avec une méthode virtuelle puisque la signature doit être la même; Cependant j'aimerais que la classe de base propose une méthode acceptant n'importe quels arguments et dispatch ces arguments à la bonne méthode de la bonne classe dérivée.

Le problème s'apparente à du double dispatch, mais diffère dans la nature des arguments, qui peuvent autant des types natifs que des classes, que dans leurs nombres, variable;
Le Visitor Pattern est souvent évoqué mais on ne peut pas passer d'arguments à la méthode invoquée

En gros ça ressemblerait à ceci (sous gcc 4.5):

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
45
46
47
48
49
50
51
52
53
 
class Base {
 
  public:
 
  Base();
  ~Base();
 
  template<typename ...Args>
  void execute(Args... arg)
  {
    //appelle la bonne méthode
    //execute(int i) or execute(int i, float f)
    //selon que Args soient int ou bien int et float
  }
 
};
 
class DerivedA : public Base
{
 
  public:
 
  DerivedA();
  ~DerivedA();
 
  void execute(int i){ /*do something with i*/}
 
};
 
class DerivedB : public Base
{
 
  public:
 
  DerivedB();
  ~DerivedB();
 
  void execute(int i, float f){/*do something with i and f*/}
 
};
 
void test()
{
  Base* b1 = new DerivedA();
  Base* b2 = new DerivedB();
 
  int i = 5;
  b1->execute(i); //devrait appeler DerivedA.execute(int i)
  float f = 5.0f;
  b2->execute(i, f); //devrait appeler DerivedB.execute(int i, float f)
 
}

Existe-t-il une solution performante et si possible pas trop compliquée pour réaliser ça ?
Je me rends compte également que la vérification de l'existence de la méthode invoquée se ferait au runtime dans mon code, est il possible de faire ça à la compilation ?

[koala01]

Salut,

Il y a deux solutions en fonction de ta situation réelle ...

Soit (ce serait le plus simple ), il est possible d'avoir une version sans arguments ou avec des argument clairement définis pour la classe de base, et, dans ce cas, les versions utilisant des arguments de types différents se chargent de faire la conversion avant d'invoquer la fonction de base :

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
class Base
{
    public:
        void doSomething(std::string const & str)
        {
            /*...*/
        }
};
class Derived1 : public Base
{
    public:
        void doSomething(int i)
        {
            std::stringstream ss;
            ss<<i;
            doSomething(ss.str() );
        }
};
class Derived1 : public Base
{
    public:
        void doSomething(float f)
        {
            std::stringstream ss;
            ss<<f;
            doSomething(ss.str() );
        }
};

soit tu ne sais pas exactement quel type de donnée devra etre manipulé, mais tu sais comment il devra l'être et, au besoin, tu as défini une interface précise pour pouvoir manipuler tes données.

Tu es alors dans le cas où une fonction template semble particulièrement adaptée dans la classe de base, sans qu'il soit besoin de rajouter quoi que de soit dans les classes dérivées :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Base
{
    public:
        template <typename Data>
        void doSomething(Data const  & d)
        {
             /* tout ce qu'il faut, c'est que le type réel de Data expose une
              * interface clairement définie
              */
        }
};

NOTA : la première solution proposée autorise la virtualité de la fonction (utilisant la std::string selon l'exemple), mais sera-t-elle nécessaire
La version utilisant les template ne pourra pour sa part pas vraiment etre virtualisée... mais rien n'empêche, dans la logique d'exécution, de faire appel à des fonctions virtuelles

[coda_blank]

Salut,

Il y a deux solutions en fonction de ta situation réelle ...

Soit (ce serait le plus simple ), il est possible d'avoir une version sans arguments ou avec des argument clairement définis pour la classe de base, et, dans ce cas, les versions utilisant des arguments de types différents se chargent de faire la conversion avant d'invoquer la fonction de base :

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
class Base
{
    public:
        void doSomething(std::string const & str)
        {
            /*...*/
        }
};
class Derived1 : public Base
{
    public:
        void doSomething(int i)
        {
            std::stringstream ss;
            ss<<i;
            doSomething(ss.str() );
        }
};
class Derived1 : public Base
{
    public:
        void doSomething(float f)
        {
            std::stringstream ss;
            ss<<f;
            doSomething(ss.str() );
        }
};

je ne comprends pas, tu veux dire que doSomething de la classe dérivée serait appelée avant celle de la classe de base ? c'est possible ?

soit tu ne sais pas exactement quel type de donnée devra etre manipulé, mais tu sais comment il devra l'être et, au besoin, tu as défini une interface précise pour pouvoir manipuler tes données.

Tu es alors dans le cas où une fonction template semble particulièrement adaptée dans la classe de base, sans qu'il soit besoin de rajouter quoi que de soit dans les classes dérivées :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Base
{
    public:
        template <typename Data>
        void doSomething(Data const  & d)
        {
             /* tout ce qu'il faut, c'est que le type réel de Data expose une
              * interface clairement définie
              */
        }
};

NOTA : la première solution proposée autorise la virtualité de la fonction (utilisant la std::string selon l'exemple), mais sera-t-elle nécessaire
La version utilisant les template ne pourra pour sa part pas vraiment etre virtualisée... mais rien n'empêche, dans la logique d'exécution, de faire appel à des fonctions virtuelles

dans ta deuxième solution, tu proposes simplement le même traitement de manière générique ? et ça n'autorise qu'un seul argument ?

[koala01]

je ne comprends pas, tu veux dire que doSomething de la classe dérivée serait appelée avant celle de la classe de base ? c'est possible ?

Ben, si tu dispose de l'objet sous son type réel (que tu a un objet Derived1 ou Derived2, d'après l'exemple), en passant au besoin par un dowcast (j'admets que ce n'est pas vraiment recommandé, mais bon, si tu n'as pas d'autre choix...), tu peux parfaitement appeler la fonction qui utilise un paramètre particulier :

Les appels suivants sont tout à fait légaux

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main()
{
    Derived1 d1;
    Derived2 d2;
    Base *b = new Derived1;
    /* appel des versions surchargées */
    d1.doSomething(1);
    d2.doSomething(3.1415926);
    dynamic_cast<Derived1*>(b)->doSomething(10);
    /* appel des versions "de base */
    d1.doSomething(std::string("Salut"));
    d2.doSomething(std::string("Monde"));
    b->doSomething(std::string("Hello"));
}

Après tout, nous somme "simplement" dans une configuration "classique" de surchage de fonction... :

doSomething(std::string const &) est disponible pour le type Base et, du fait de l'héritage, pour les types Derived1 et Derived2.

de leur coté Derived1 dispose d'une surcharge sous la forme de doSomething(int) et Derived2 sous la forme de doSomething(float)Le fait d'effectuer une conversion avant d'appeler une autre version de la fonction est pratique courante pour éviter la multiplication de code...Regarde dans n'importe quel bibliothèque n'importe quelle fonction surchargée
[quote]
dans ta deuxième solution, tu proposes simplement le même traitement de manière générique ?[QUOTE]Oui.

C'est le cas d'utilisation de base exact de la généricité : on ne sait pas exactement quel type de donnée sera manipulé, mais on sait exactement comment les données seront manipulées

il et ça n'autorise qu'un seul argument ?

Absolument pas...

Tu peux parfaitement multiplier les type à loisir (ou du moins à besoin)!

Le code suivant serait tout à fait légal

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
class Base
{
    public:
        template <typename T1,
                  typename T2,
                  typename T3,
                  typename T4,
                  typename T5 >
        void doSomething(T1 arg1,
                         T2 arg2,
                         T3 arg3,
                         T4 arg4,
                         T5 arg5)
        {
             /* tout ce qu'il faut, c'est que les types réels utilisés pour
              *  T1 à T5 exposent chacun une interface clairement définie qui
              * leur soit propre
              */
        }
};

[3DArchi]

Salut,

En gros ça ressemblerait à ceci (sous gcc 4.5):

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
45
46
47
48
49
50
51
52
53
 
class Base {
 
  public:
 
  Base();
  ~Base();
 
  template<typename ...Args>
  void execute(Args... arg)
  {
    //appelle la bonne méthode
    //execute(int i) or execute(int i, float f)
    //selon que Args soient int ou bien int et float
  }
 
};
 
class DerivedA : public Base
{
 
  public:
 
  DerivedA();
  ~DerivedA();
 
  void execute(int i){ /*do something with i*/}
 
};
 
class DerivedB : public Base
{
 
  public:
 
  DerivedB();
  ~DerivedB();
 
  void execute(int i, float f){/*do something with i and f*/}
 
};
 
void test()
{
  Base* b1 = new DerivedA();
  Base* b2 = new DerivedB();
 
  int i = 5;
  b1->execute(i); //devrait appeler DerivedA.execute(int i)
  float f = 5.0f;
  b2->execute(i, f); //devrait appeler DerivedB.execute(int i, float f)
 
}

Quid si je fait :

Code :

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

1
2
3
4
5
 
  int i = 5;
  b2->execute(i); 
  float f = 5.0f;
  b1->execute(i, f);

Bref, si tu proposes une interface via la classe de base, le LSP est-il toujours respecté ?
Seconde question, dans la réalité, si les paramètres varient, au moment de l'appel de la fonction as-tu vraiment qu'un type de base ou sais-tu quel est le type effectif de la fonction appelée ? Car en ce cas, la fonction n'a pas à être définie au niveau de la classe de base mais bien des dérivées.