Come posso passare una funzione membro in cui è prevista una funzione libera?

La domanda è la seguente: considera questo pezzo di codice:

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

Come posso usare a's aClass::testcome argomento per function1? Sono bloccato nel farlo.

Vorrei accedere a un membro della classe.

Non c'è niente di sbagliato nell'usare i puntatori a funzione. Tuttavia, i puntatori a funzioni membro non statiche non sono come i normali puntatori a funzioni: le funzioni membro devono essere chiamate su un oggetto che viene passato come argomento implicito alla funzione. La firma della tua funzione membro sopra è, quindi

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

piuttosto che il tipo che si tenta di utilizzare

void (*)(int, int)

Un approccio potrebbe consistere nel far funzionare il membro, staticnel qual caso non richiede il richiamo di alcun oggetto e puoi usarlo con il tipo void (*)(int, int).

Se hai bisogno di accedere a qualsiasi membro non statico della tua classe e devi restare con i puntatori a funzione, ad esempio, perché la funzione fa parte di un'interfaccia C, la tua migliore opzione è quella di passare sempre a void*alla tua funzione prendendo puntatori di funzione e chiamando il membro tramite una funzione di inoltro che ottiene un oggetto da void*e quindi chiama la funzione membro.

In una corretta interfaccia C ++ potresti voler dare un'occhiata al fatto che la tua funzione prenda un argomento basato su modelli per gli oggetti funzione per usare tipi di classe arbitrari. Se l'utilizzo di un'interfaccia basata su modelli non è desiderabile, dovresti usare qualcosa di simile std::function<void(int, int)>: puoi creare un oggetto funzione richiamabile in modo appropriato per questi, ad esempio, using std::bind().

Gli approcci indipendenti dai tipi che utilizzano un argomento modello per il tipo di classe o uno adatto std::function<...>sono preferibili rispetto all'utilizzo di void*un'interfaccia poiché rimuovono il potenziale di errori dovuti a un cast al tipo sbagliato.

Per chiarire come utilizzare un puntatore a funzione per chiamare una funzione membro, ecco un esempio:

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

La risposta di @Pete Becker va bene, ma puoi anche farlo senza passare l' classistanza come parametro esplicito function1in 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;
}

Un puntatore a una funzione membro è diverso da un puntatore a una funzione. Per poter utilizzare una funzione membro tramite un puntatore è necessario un puntatore ad essa (ovviamente) e un oggetto a cui applicarlo. Quindi la versione appropriata di function1sarebbe

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

e per chiamarlo:

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

Dal 2011, se puoi cambiare function1, fallo in questo modo:

#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 live )

Si noti anche che ho corretto la definizione dell'oggetto danneggiato ( aClass a();dichiara una funzione).

Ho posto una domanda simile ( C ++ openframeworks passando void da altre classi ) ma la risposta che ho trovato era più chiara, quindi ecco la spiegazione per i record futuri:

è più facile usare std :: function come in:

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

e poi chiama come:

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

o anche più facile:

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

dove crei un lambda che chiama l'oggetto catturandolo per riferimento

Ho fatto funzionare il membro come statico e tutto funziona:

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

Non sono sicuro del motivo per cui questa soluzione incredibilmente semplice sia stata ignorata:

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

Produzione:

1 - 1 = 0
1 + 1 = 2

Se in realtà non hai bisogno di usare l'istanza a (cioè puoi renderla statica come la risposta di @mathengineer ) puoi semplicemente passare un lambda non acquisito. (che decade in puntatore a funzione)

#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

nota: se aClassè costoso da costruire o ha un effetto collaterale, questo potrebbe non essere un buon metodo.

Puoi smetterla di sbattere la testa adesso. Ecco il wrapper per la funzione membro per supportare le funzioni esistenti che assumono semplici funzioni C come argomenti. thread_localla direttiva è la chiave qui.

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

Si prega di commentare eventuali problemi con questo approccio.

Altre risposte non riescono a chiamare leC funzioni normali esistenti : http://cpp.sh/8exun