Jak mogę przekazać funkcję członkowską, w której oczekuje się wolnej funkcji?

@Pete Becker ' s answer is fine but you can also do it without passing the class instance as an explicit parameter to function1 in C++ 11:

#include <functional>
using namespace std::placeholders;

void function1(std::function<void(int, int)> fun)
{
    fun(1, 1);
}

int main (int argc, const char * argv[])
{
   ...

   aClass a;
   auto fp = std::bind(&aClass::test, a, _1, _2);
   function1(fp);

   return 0;
}

Wskaźnik do funkcji członka różni się od wskaźnika do funkcji. Aby użyć funkcji członka za pomocą wskaźnika, potrzebujesz wskaźnika do niej (oczywiście ) I obiektu do zastosowania go. Więc odpowiednią wersją function1 będzie

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

I nazwać go:

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

Od 2011 roku, jeśli możesz zmienić function1, Zrób to tak:

#include <functional>
#include <cstdio>

using namespace std;

class aClass
{
public:
    void aTest(int a, int b)
    {
        printf("%d + %d = %d", a, b, a + b);
    }
};

template <typename Callable>
void function1(Callable f)
{
    f(1, 1);
}

void test(int a,int b)
{
    printf("%d - %d = %d", a , b , a - b);
}

int main()
{
    aClass obj;

    // Free function
    function1(&test);

    // Bound member function
    using namespace std::placeholders;
    function1(std::bind(&aClass::aTest, obj, _1, _2));

    // Lambda
    function1([&](int a, int b) {
        obj.aTest(a, b);
    });
}

(live demo )

Zauważ również, że naprawiłem Twoją zepsutą definicję obiektu (aClass a(); deklaruje funkcję).

Możecie przestać walić się w głowy. Oto wrapper dla funkcji member obsługującej istniejące funkcjeprzyjmujące jako argumenty zwykłe funkcje C. thread_local dyrektywa jest tutaj kluczem.

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

Proszę skomentować wszelkie problemy z tym podejściem.

Inne odpowiedzi nie wywołują istniejących zwykłych C funkcji: http://cpp.sh/8exun