Foncteur, variadic templates et héritage

Version imprimable

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:

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:

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:

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 ? :P

Il me semble que pour capturer les arguments, il faut d'abord les stocker dans un membre de type std::tuple<Args...> puis réutiliser ce tuple dans execute(). Mais ça devient vite extrêmement casse tête.

Avant d'aller plus loin, je voudrais faire remarquer que GenFonc est très similaire à std::bind. Il faudrait peut être commencer par là. :mrgreen:

Je ne sais pas si tu est familier avec std::bind alors au cas où, voici un topo :

std::bind est une fonction générant un foncteur qui bind un objet avec une fonction membre (entre autre), permettant un appel tardif.
Le foncteur généré par std::bind est capable, comme tu le souhaites, soit d'accepter les arguments lors de l'appel du foncteur, soit de stocker directement les arguments lors de la création du foncteur pour les réutiliser lors de l'appel, comme ceci :
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 #include <string> #include <iostream> #include <functional> using namespace std; using namespace std::placeholders; 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; string s = "toto"; // avec placeholders qui indique que le foncteur généré // attends les arguments lors de l'appel. auto b1 = bind(&Print::print1, &p, _1, _2); // placeholders b1(s, "test"); // sans placeholder, les arguments sont stockés par copie // dans le foncteur généré par bind //(probablement dans un tuple membre de ce foncteur) auto b2 = bind(&Print::print1, &p, s, string("test")); b2(); }
Le seul petit souci de std::bind c'est que le foncteur généré possède un type qui est laissé au choix du compilateur, j'ai donc été obligé d'utiliser auto dans l'exemple pour déduire ce type automatiquement.
Dans le cas de visual studio, je peux voir au debugger que le type réel est, attention les yeux:

Citation:

"std::tr1::_Bind<void,void,std::tr1::_Bind3<std::tr1::_Callable_pmf<void (__thiscall Print::*const)(std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::basic_string<char,std::char_traits<char>,std::allocator<char> >),Print,0>,Print *,std::tr1::_Ph<1>,std::tr1::_Ph<2> > >"

Clairement, ce n'est pas très portable. :mouarf:

C'est pour ça qu'on utilise en général std::function + std::bind pour résoudre complètement le problème.

std::function<R(Args...)> est un wrapper généraliste permettant de wrapper n'importe quelle construction C++ étant "appelable" comme une fonction prenant des arguments Args... et retournant R, c'est à dire qui visuellement peuvent être appelées comme ceci:

Code:

R r = f(arg1, arg2, ... argn);

f pouvant être une fonction, un pointeur de fonction ou un foncteur.

Et justement, std::function<R(Args...)> est entre autres capable de wrapper et stocker certains foncteurs produits par std::bind ! On peut donc faire :
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 #include <string> #include <iostream> #include <functional> using namespace std; using namespace std::placeholders; 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; string s = "toto"; function<void(string, string)> gf1(bind(&Print::print1, &p, _1, _2)); gf1(s, "test"); function<int(void)> gf2(bind(&Print::print2, &p)); int n = gf2(); s = "toto"; function<void()> gf3(bind(&Print::print1, &p, s, string("test"))); gf3(); }
L'avantage étant que l'on peut stocker des std::function dans un vector par exemple, vu qu'on connait leur type cette fois.

25/09/2011, 13h57
coda_blank

J'hésitais à utiliser bind et function n'étant pas ûr que l'on pouvait entrer n'importe quel nombre d'arguments ,et ce, sans sans préciser les arguments de templates :)
Là je crois qu'il sera difficile de trouver mieux :D

Merci pour tout ;)

(je réactive ce fil temporairement pour éviter d'en créer un nouveau)

j'aimerais juste pouvoir stocker dans un même conteneur les deux types de foncteurs, sans placeholders et avec placeholders

pour le premier cas c'est pas trop dur puique function<void()> accepte toutes les fonctions quelques soient les arguments :

Command :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
class CommandBase
{
  public :
    virtual void execute() = 0;
};
 
class Command : public CommandBase
{
  std::function<void()> f_;
  public:
    Command() {}
    Command(std::function<void()> f) : f_(f) {}
 
    void execute() { if(f_) f_(); }
    template <typename Func> void setFunction(Func f) { f_ = f; }
 
};

CoimmandManager :

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
 
class CommandManager
{
  typedef map<string, CommandBase*> FMap;
 
  public :
 
    void add(string name, CommandBase* cmd)
    {
      fmap1.insert(pair<string, CommandBase*>(name, cmd));
    }
 
    void execute(string name)
    {
      FMap::const_iterator it = fmap1.find(name);
      if(it != fmap1.end())
      {
          CommandBase* c = it->second;
          c->execute();
      }
    }
 
  private :
 
    FMap fmap1;
 
};

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
 
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()
 
      function<void()> f1(bind(&Print::print1, &p, string("test1"), string("test2")));
 
      function<int(void)> f2(bind(&Print::print2, &p));
 
      CommandManager cmdMgr = CommandManager();
      CommandBase* cmdb1 = new Command(f1);
      cmdMgr.add("print1", cmdb1);
      cmdMgr.execute("print1");
 
      CommandBase* cmdb2 = new Command(f2);
      cmdMgr.add("print2", cmdb2);
      cmdMgr.execute("print2");
 
      return 0;
}

maintenant le second cas me pose plus de problèmes; il ne semble pas possible de "caster" une fonction bindée avec placeholders en une fonction<void()>

alors j'ai tenté ceci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
template<typename...Args>
class Command2 : public CommandBase
{
  std::function<void(Args...)> f_;
  public:
    Command2<Args...>() {}
    Command2<Args...>(std::function<void(Args...)> f) : f_(f) {}
 
    virtual void execute(Args... args) { if(f_) f_(args...); }
    template <typename Func> void setFunction(Func f) { f_ = f; }
 
};

qui utilisé comme ceci :

Code:

1
2
3
4
 
function<void(string, string)> f3(bind(&Print::print1, &p, placeholders::_1, placeholders::_2));
 
CommandBase* cmdb3 = new Command2<string, string>(f3);

me génère bien sûr une erreur :

Code:

1
2
3
4
 
error: cannot allocate an object of abstract type ‘Command2<std::basic_string<char>, std::basic_string<char> >’
../src/Cpp0x_test.cpp:127:1: note:   because the following virtual functions are pure within ‘Command2<std::basic_string<char>, std::basic_string<char> >’:
../src/Cpp0x_test.cpp:122:18: note: 	virtual void CommandBase::execute()

impossible également de templater execute() puisqu'elle est virtuelle

02/10/2011, 18h55
Flob90

Bonjour,

1/ Tu cherches à faire un pattern command ? Dans ce cas c'est étrange c'est déjà ce que fait std::function, ie tu réalises une encapsulation de std::function que n'apporte aucun service suplémentaire (et probablement moins de service même).

2/ Pour ton erreur c'est normal, executer() est virtuelle pure dans la classe mère, donc si tu veux instancier une classe fille il faut définir executer() dedans. Le polymorphisme n'est pas directement une solution à ton problème (que je n'ai pas encore bien saisie), f.executer() n'a aucun sens si la classe fille gère un foncteur à arguments, executer n'attend pas d'argument tu ne peux pas lui passer via executer.

Si tu peux, penches toi sur un implémentation de function (boost ou loki), ou un explication détaillée (MC++D a un chapitre à ce sujet).

Citation:

Envoyé par Flob90

Bonjour,

1/ Tu cherches à faire un pattern command ? Dans ce cas c'est étrange c'est déjà ce que fait std::function, ie tu réalises une encapsulation de std::function que n'apporte aucun service suplémentaire (et probablement moins de service même).

le problème c'est que je ne peux pas faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 Print p = Print(); function<void(string, string)> f1(bind(&Print::print1, &p, placeholders::_1, placeholders::_2)); //on cast f1 vers f2 => erreur de compilation function<void()> f2 = f1; //on place f2 dans un conteneur vector<function<void()>> vec; vec.push_back(f2); //on récupère f2 function<void()> f3 = vec.at(n); //on execute print1 f3("test1", "test2");
il faut donc que je masque function<void(string, string)> avec une encapsulation;

Et je ne parle même pas du type de retour, par exemple si j'utilise print2

Citation:

Si tu peux, penches toi sur un implémentation de function (boost ou loki), ou un explication détaillée (MC++D a un chapitre à ce sujet).

std::function n'est elle pas une copie conforme de boost::function ?
qu'apporteraient ces librairies par rapport à la stl?

02/10/2011, 20h20
Flob90

Je voulais dire regarder comment est fait function à l'intérieur, après quel version tu prends pour regarder ca va pas changer grand chose, sauf la lisibilité du code peut-etre.

Pour ton problème, tu as une collection limité de signatures possible ou pas ? Si oui : boost::variant + std::function, si non boost::any (ou poco::any) + std::function.

Cependant pourquoi veux-tu faire ceci ? En général une collection de types hétérogène (non polymorphe) c'est un signe de danger. Qu'est ce qui justifie que tu rassembles des foncteurs qui n'ont rien à voir entre eux ?

Citation:

Envoyé par Flob90

Pour ton problème, tu as une collection limité de signatures possible ou pas ? Si oui : boost::variant + std::function, si non boost::any (ou poco::any) + std::function.

le nombre et le type des arguments peut varier mais les fonctions renvoient toujours un void

Citation:

Cependant pourquoi veux-tu faire ceci ? En général une collection de types hétérogène (non polymorphe) c'est un signe de danger. Qu'est ce qui justifie que tu rassembles des foncteurs qui n'ont rien à voir entre eux ?

pour pouvoir différer les appels de n'importe quelle fonction dans le temps
le but du pattern Command en somme

J'aimerais aussi déclencher un appel à partir d'une chaines de caractere

Par exemple (en pseudo code):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //on lie une méthode à un objet Command Command cmd = Command(&Print::print1, &p, placeholders::_1, placeholders::_2 ) //On l'ajoute à un Interpreteur (une sorte de map) qui stocke toutes les commandes Interpreter.add("print1", cmd); //Plus tard on a besoin d'appeler print1 //On définit un appel et ses paramètres string call = "print1('test', 'test2')" //l'interpréteur recherche la commande désirée et l'execute en lui passant les paramètres Interpreter.execute(call);
Tout ça parce que je trouve les bindings de langages de scripts (comme luaPlus ou luabind) trop lents :)

02/10/2011, 22h15
Flob90

Tentes quelque chose à base de boost::any et std::function, ca doit pouvoir marcher, cependant on doit pouvoir faire bien mieux.

Sinon regardes Camp je l'ai jamais vraiment utilisé mais je l'avais retenue comme bibliothèque pouvant servir pour le scriptage.