Je viens de decouvrir les variadic templates (sous Gcc 4.5) et j'ai tenté de créer un petit foncteur générique qui conserve l'instance d'objet et la méthode que l'on veut y appliquer

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
 
template <typename C, typename R, typename... Args>
class GenFonc {
 
typedef R (C::*functor)(Args...);
 
public:
 
  GenFonc(C& obj, functor f):mObj(obj), mf(f){}
 
  R execute(Args... args)
  {
    return (mObj.*mf)(args...);
  }
 
private :
 
    C& mObj;
    functor mf;
 
};
Par contre je n'ai pas trouvé le moyen de conserver Args... d'une manière ou d'une autre, je suis donc obligé d'utiliser le foncteur comme ceci :

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
class Print{

public:
  void print1(string s, string s1){ cout<<"print1 : "<<"s : "<<s<<" s1 : "<<s1<<endl; }
  int print2(){ cout<<"print2"<<endl; return 2;}

};

int main(){

Print p = Print();

string s = "toto";
GenFonc<Print, void, string, string> gf1(p, &Print::print1);
gf1.execute(s, "test");

GenFonc<Print, int> gf2(p, &Print::print2);
int n = gf2.execute();

//je voudrais faire ceci :
string s = "toto";
GenFonc<Print, void, string, string> gf1(p, &Print::print1, s, "test");
gf1.execute();

}
Je voudrais donc différer l'appel

Autre souci, l'impossibilité d'hériter d'une classe abstraite car obligé de conserver la même signature pour execute(...) et donc de conserver les paramètres templates

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
class GenFoncBase
{
  public :
      virtual ? execute(?) = 0;
};
Ce qui du coup m'interdit de placer mon foncteur dans un conteneur STL

Est il possible de sortir de cette impasse ?