passer des fonctions

Question

Ok, ça fait longtemps que j'ai écrit en C++. et je n'ai jamais rien fait de silencieux à ce niveau élevé.

Donc, fondamentalement, je dois créer une classe. Le constructeur de la classe doit prendre une référence (ou un pointeur) à une méthode d'une autre classe ou à une fonction.

Fondamentalement, j'ai une classe qui a besoin de lire occasionnellement une valeur à partir d'un évaluateur fltk (version 1.1.x), puis de modifier certaines choses sur lui-même. Chaque objet sera associé à son propre évaluateur. (ils ont aussi un lien vers un autre objet du même parent, qui après s'être mis à jour de l'évaluateur dira mettre à jour, et ainsi de suite)

Alors, comment est-ce que je passe les fonctions, dans les constructeurs?

Answer 1

Voici un exemple où une méthode de Foo est passé au constructeur Bar et plus tard invoqué sur un objet Bar donné:

struct Foo 
{ 
    int z; 

    int add(int x, int y) 
    { 
     return x + y + z; 
    } 

    int mul(int x, int y) 
    { 
     return x * y * z; 
    } 
}; 

typedef int (Foo::*foo_method)(int, int); 

struct Bar 
{ 
    foo_method m; 

    Bar(foo_method m) : m(m) {} 

    int call_on(Foo* foo) 
    { 
     return (foo->*m)(4, 2); 
    } 
}; 

int main() 
{ 
    Bar bar(&Foo::add); 

    Foo foo = { 123 }; 
    bar.call_on(&foo); 
} 

Si, d'autre part, vous savez déjà l'objet Foo à Bar temps de construction, alors Bar ne se soucie pas vraiment à quelle classe appartient la méthode. Tout ce dont il a besoin est un foncteur à appeler plus tard, et l'objet Foo peut simplement être lié par le client.

#include <functional> 

struct Bar 
{ 
    std::function<int (int, int)> f; 

    Bar(std::function<int (int, int)> f) : f(f) {} 

    int call() 
    { 
     return f(4, 2); 
    } 
}; 

using namespace std::placeholders; 

int main() 
{ 
    Foo foo = { 123 }; 
    Bar bar(std::bind(&Foo::add, &foo, _1, _2)); 

    bar.call(); 
} 

Si vous ne disposez pas d'un compilateur C++ 0x, remplacez std::bind avec std::tr1::bind ou boost::bind.

Answer 2

Votre constructeur pourrait ressembler à ceci:

// convenient typedef. This is for a pointer to a function in Foo 
// The function returns void and takes no parameters. 
typedef void (Foo::*FooPtr)(); 

class Bar { 
public: 
    Bar (FooPtr foo_ptr); 
}; 

Découvrez quelques références web pour plus de détails sur la syntaxe pour pointer à des membres. C'est beaucoup plus facile si vous le connaissez d'abord.

Pour plus d'informations, consultez les fonctions mem_fun et mem_fun_ref. Ceux-ci peuvent faire ce dont vous avez besoin.

Answer 3

La façon la plus simple de capturer cela est avec boost::function. Il peut stocker des pointeurs de fonction, mais aussi le résultat de la liaison d'une fonction membre à un objet.

Par exemple,

class Foo { 
    Foo(boost::function<int(void)>); 
}; 

vous permettra d'accepter toute source d'entiers.