Wie kann ich pass eine member-Funktion, in dem eine freie Funktion erwartet wird?

Gibt es nichts falsch mit der Verwendung von Funktionszeigern. Jedoch, Zeiger auf nicht-statischen member-Funktionen sind nicht wie die normalen Funktionszeiger: member-Funktionen müssen aufgerufen werden, ein Objekt, das übergeben wird, als eine implizite argument an die Funktion. Die Unterzeichnung des member-Funktion oben ist, so

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

eher als der Typ, den Sie versuchen zu verwenden

void (*)(int, int)

Könnte ein Ansatz darin bestehen, machen die member-Funktion static in dem Fall ist es nicht erforderlich, dass jedes Objekt, um aufgerufen werden, und Sie können es verwenden, mit der Art void (*)(int, int).

Wenn Sie brauchen, um Zugriff auf nicht-statische member der Klasse und müssen Sie halten mit Funktionszeigern, z.B., weil die Funktion ist Teil der C-Schnittstelle, die beste option, um immer den pass ein void* auf Ihre Funktion, die Funktion Zeiger und rufen Sie Ihr Mitglied über eine weiterleitende Funktion erhält ein Objekt aus der void* und ruft dann die member-Funktion.

In einem richtigen C++ - Schnittstelle möchten Sie vielleicht einen Blick zu haben an, dass Sie Ihre Funktion nutzen und vorgefertigte argument für die Funktion der Objekte, um beliebige Klasse Typen. Wenn Sie eine vorgefertigte Schnittstelle ist unerwünscht, Sie sollte so etwas wie std::function<void(int, int)>: erstellen Sie ein entsprechend callable function-Objekt für diese, z.B. mithilfe std::bind().

Typ-sichere Ansätze mit einem template-argument für die Klasse, Typ oder einem geeigneten std::function<...> sind vorzuziehen, als mit einem void* - Schnittstelle, wie Sie entfernen Sie das Potenzial für Fehler aufgrund eines cast auf den richtigen Typ.

Geklärt werden, wie eine Funktion Zeiger auf Aufruf einer member-Funktion, hier ein Beispiel:

//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);
}

Einen Zeiger auf member-Funktion unterscheidet sich von einem Zeiger auf Funktion. Damit eine member-Funktion über einen Zeiger muss ein Zeiger auf (offensichtlich), und ein Objekt, um es anzuwenden. Also die entsprechende version von function1 wäre

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

und nennen es:

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

Stellte ich eine ähnliche Frage ( C++, openframeworks übergeben void von anderen Klassen ), aber die Antwort, die ich fand, war klarer, so dass hier die Erklärung für Zukunft records:

es ist einfacher zu bedienen std::function-in:

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

und dann rufen wie:

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

oder noch einfacher:

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

dem erstellen Sie einen lambda-Ausdruck, ruft das Objekt die Erfassung von Referenz -

Machte ich die member-Funktion als statische und alles funktioniert:

#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;
}