Appeler la bonne méthode de l'objet selon le nombre et le type des arguments
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:
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 ?
