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

Pytanie jest następujące: rozważ ten fragment kodu:

#include <iostream>


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

void function1(void (*function)(int, int))
{
    function(1, 1);
}

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

int main (int argc, const char* argv[])
{
    aClass a();

    function1(&test);
    function1(&aClass::aTest); // <-- How should I point to a's aClass::test function?

    return 0;
}

Jak mogę korzystać z a„s aClass::testjako argument function1? Utknąłem w tym.

Chciałbym uzyskać dostęp do członka klasy.

Nie ma nic złego w używaniu wskaźników funkcji. Jednak wskaźniki do niestatycznych funkcji składowych nie są podobne do zwykłych wskaźników do funkcji: funkcje składowe muszą być wywoływane w obiekcie, który jest przekazywany jako niejawny argument funkcji. Zatem podpis twojej funkcji członkowskiej powyżej to

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

zamiast typu, którego próbujesz użyć

void (*)(int, int)

Jedno podejście mogłoby polegać na utworzeniu funkcji składowej, staticw którym to przypadku nie wymaga ona wywołania żadnego obiektu i można jej użyć z typem void (*)(int, int).

Jeśli potrzebujesz dostępu do dowolnego niestatycznego elementu członkowskiego swojej klasy i musisz trzymać się wskaźników do funkcji, np. Ponieważ funkcja jest częścią interfejsu C, najlepszą opcją jest zawsze przekazywanie void*do funkcji a, przyjmując wskaźniki do funkcji i wywołując Twój element członkowski za pośrednictwem funkcji przekazującej, która uzyskuje obiekt z, void*a następnie wywołuje funkcję składową.

W odpowiednim interfejsie C ++ możesz rzucić okiem na to, aby Twoja funkcja pobierała argument oparty na szablonie dla obiektów funkcji, aby używały dowolnych typów klas. Jeśli używanie szablonu interfejsu jest niepożądane, powinieneś użyć czegoś takiego std::function<void(int, int)>: możesz utworzyć dla nich odpowiednio wywoływalny obiekt funkcji, np std::bind(). Using .

Podejścia z bezpiecznym typem przy użyciu argumentu szablonu dla typu klasy lub odpowiedniego std::function<...>są lepsze niż użycie void*interfejsu, ponieważ eliminują potencjalne błędy wynikające z rzutowania na niewłaściwy typ.

Aby wyjaśnić, jak używać wskaźnika funkcji do wywoływania funkcji składowej, oto przykład:

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

Odpowiedź @Pete Becker jest w porządku, ale możesz to również zrobić bez przekazywania classinstancji jako jawnego parametru function1w 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 składowej różni się od wskaźnika do funkcji. Aby użyć funkcji składowej za pośrednictwem wskaźnika, potrzebujesz wskaźnika do niej (oczywiście) i obiektu, do którego chcesz ją zastosować. Więc odpowiednia wersja function1będzie

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

i nazwać to:

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

Od 2011, jeśli możesz to zmienić function1, zrób to w ten sposób:

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

( demo na żywo )

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

Zadałem podobne pytanie ( otwarte ramy C ++ przechodzą nieważne z innych klas ), ale odpowiedź, którą znalazłem, była jaśniejsza, więc tutaj wyjaśnienie dla przyszłych rekordów:

łatwiej jest użyć funkcji std :: jak w:

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

a następnie zadzwoń jako:

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

lub jeszcze łatwiej:

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

gdzie tworzysz lambdę, która wywołuje obiekt przechwytujący go przez odniesienie

Zrobiłem element członkowski jako statyczny i wszystko działa:

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

Nie jestem pewien, dlaczego pominięto to niezwykle proste rozwiązanie:

#include <stdio.h>

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

template<class C>
void function1(void (C::*function)(int, int), C& c)
{
    (c.*function)(1, 1);
}
void function1(void (*function)(int, int)) {
  function(1, 1);
}

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(&test);
    function1<aClass>(&aClass::aTest, a);
    return 0;
}

Wynik:

1 - 1 = 0
1 + 1 = 2

Jeśli faktycznie nie trzeba korzystać z instancji a (czyli można je statyczne jak @mathengineer „s odpowiedzi ) można po prostu przejść w lambda non-capture. (które rozpadają się na wskaźnik funkcji)

#include <iostream>

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

void function1(void (*function)(int, int))
{
    function(1, 1);
}

int main()
{
   //note: you don't need the `+`
   function1(+[](int a,int b){return aClass{}.aTest(a,b);}); 
}

Wandbox

uwaga: jeśli aClassjest kosztowna w budowie lub ma efekt uboczny, może to nie być dobry sposób.

Możesz teraz przestać walić głową. Oto opakowanie dla funkcji składowej do obsługi istniejących funkcji przyjmujących zwykłe funkcje C jako argumenty. thread_localDyrektywa jest tutaj kluczowa.

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

Prosimy o skomentowanie wszelkich problemów związanych z tym podejściem.

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