Comment puis-je passer d'une fonction membre où une fonction libre est prévu?

Il n'y a pas quelque chose de mal avec l'aide de pointeurs de fonction. Cependant, des pointeurs vers des non-fonctions membres statiques ne sont pas comme les pointeurs de fonction: les fonctions doivent être appelées sur un objet qui est passé comme un implicite argument de la fonction. La signature de votre membre de la fonction ci-dessus est donc

void (aClass::*)(int, int)

plutôt que le type que vous essayez d'utiliser

void (*)(int, int)

Une approche pourrait consister à faire de la fonction de membre de static dans ce cas elle n'a pas besoin d'objet pour être appelé et vous pouvez l'utiliser avec le type void (*)(int, int).

Si vous avez besoin d'accéder à tout non-membre statique de votre classe et vous avez besoin de coller avec des pointeurs de fonction, par exemple, parce que la fonction est une partie d'une interface C, votre meilleure option est de toujours passer un void* à votre fonction prenant des pointeurs de fonction et appelez votre membre par le biais d'une fonction de transmission qui obtient un objet à partir de la void*, puis appelle la fonction membre.

Dans une bonne interface C++, vous pouvez avoir un coup d'oeil à avoir votre prise de fonction de type "modèle" argument de la fonction des objets à usage arbitraire types de classe. Si vous utilisez basé sur un modèle d'interface n'est pas souhaitable que vous devriez utiliser quelque chose comme std::function<void(int, int)>: vous pouvez créer un convenablement appelable de la fonction de l'objet pour ces, par exemple, à l'aide de std::bind().

Le type-safe approches à l'aide d'un argument de modèle pour le type de classe ou un std::function<...> est préférable que l'utilisation d'une void* interface, car ils suppriment le potentiel pour des erreurs dues à une fonte de type incorrect.

De clarifier comment utiliser un pointeur de fonction à appeler une fonction membre, voici un exemple:

//the function using the function pointers:
void somefunction(void (*fptr)(void*, int, int), void* context) {
    fptr(context, 17, 42);
}

void non_member(void*, int i0, int i1) {
    std::cout << "I don't need any context! i0=" << i0 << " i1=" << i1 << "\n";
}

struct foo {
    void member(int i0, int i1) {
        std::cout << "member function: this=" << this << " i0=" << i0 << " i1=" << i1 << "\n";
    }
};

void forwarder(void* context, int i0, int i1) {
    static_cast<foo*>(context)->member(i0, i1);
}

int main() {
    somefunction(&non_member, 0);
    foo object;
    somefunction(&forwarder, &object);
}

Un pointeur de fonction membre est différente à partir d'un pointeur de fonction. Pour utiliser une fonction membre par l'intermédiaire d'un pointeur vous avez besoin d'un pointeur (évidemment ) et un objet de l'appliquer à. Donc la version appropriée de function1 serait

void function1(void (aClass::*function)(int, int), aClass& a) {
    (a.*function)(1, 1);
}

et de l'appeler:

aClass a; //note: no parentheses; with parentheses it's a function declaration
function1(&aClass::test, a);

J'ai posé une question similaire ( C++ openframeworks passant nulle à partir d'autres classes ), mais la réponse que j'ai trouvé était plus clair voici donc l'explication pour les futurs enregistrements:

il est plus facile d'utiliser std::function, comme dans:

 void draw(int grid, std::function<void()> element)

et ensuite appeler comme:

 grid.draw(12, std::bind(&BarrettaClass::draw, a, std::placeholders::_1));

ou encore plus simple:

  grid.draw(12, [&]{a.draw()});

où vous créez un lambda qui appelle l'objet de la capture par référence

J'ai fait la fonction membre statique et tous les travaux:

#include <iostream>
class aClass
{
public:
static void aTest(int a, int b)
{
printf("%d + %d = %d\n", a, b, a + b);
}
};
void function1(int a,int b,void function(int, int))
{
function(a, b);
}
void test(int a,int b)
{
printf("%d - %d = %d\n", a , b , a - b);
}
int main (int argc, const char* argv[])
{
aClass a;
function1(10,12,test);
function1(10,12,a.aTest); //<-- How should I point to a's aClass::test function?
getchar();return 0;
}