Wie kann ich eine Mitgliedsfunktion übergeben, bei der 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);
}

InformationsquelleAutor der Antwort Dietmar Kühl

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

InformationsquelleAutor der Antwort Pete Becker

Können Sie zu stoppen, schlug Ihre Köpfe jetzt. Hier ist der wrapper für die Mitglied-Funktion zur Unterstützung bestehenden Funktionen nehmen in plain C Funktionen als Argumente. thread_local Richtlinie ist hier der Schlüssel.

http://cpp.sh/9jhk3

//Example program
#include <iostream>
#include <string>

using namespace std;

typedef int FooCooker_ (int);

//Existing function
extern "C" void cook_10_foo (FooCooker_ FooCooker) {
    cout << "Cooking 10 Foo ..." << endl;
    cout << "FooCooker:" << endl;
    FooCooker (10);
}

struct Bar_ {
    Bar_ (int Foo = 0) : Foo (Foo) {};
    int cook (int Foo) {
        cout << "This Bar got " << this->Foo << endl;
        if (this->Foo >= Foo) {
            this->Foo -= Foo;
            cout << Foo << " cooked" << endl;
            return Foo;
        } else {
            cout << "Can't cook " <<  Foo << endl;
            return 0;
        }
    }
    int Foo = 0;
};

//Each Bar_ object and a member function need to define
//their own wrapper with a global thread_local object ptr
//to be called as a plain C function.
thread_local static Bar_* BarPtr = NULL;
static int cook_in_Bar (int Foo) {
    return BarPtr->cook (Foo);
}

thread_local static Bar_* Bar2Ptr = NULL;
static int cook_in_Bar2 (int Foo) {
    return Bar2Ptr->cook (Foo);
}

int main () {
  BarPtr = new Bar_ (20);
  cook_10_foo (cook_in_Bar);

  Bar2Ptr = new Bar_ (40);
  cook_10_foo (cook_in_Bar2);

  delete BarPtr;
  delete Bar2Ptr;
  return 0;
}

Bitte kommentieren Sie irgendwelche Probleme mit diesem Ansatz.

Anderen Antworten ausfallen zu nennen bestehenden plain C Funktionen: http://cpp.sh/8exun

InformationsquelleAutor der Antwort neckTwi