Come posso passare una funzione membro a un puntatore a funzione?

Question

class Child;
class Parent
{
public:
  void (*funcPointer)();
  void (*funcPointer2)(Parent* _this);
  void (Child::*funcPointer3)();
};

class Child: public Parent
{
public:
  void TestFunc(){

  }
  void Do(){
    Parent p;
    p.funcPointer=TestFunc; // error, '=': cannot convert from 'void (__thiscall Child::* )(void)' to 'void (__cdecl *)(void)'
    p.funcPointer2=TestFunc; // error too, '=': cannot convert from 'void (__thiscall Child::* )(void)' to 'void (__cdecl *)(Parent *)'
    p.funcPointer3=TestFunc; //this works
    p.funcPointer3=&Child::TestFunc; // this works too.
    p.funcPointer3();    // error, term does not evaluate to a function taking 0 arguments
  }
};

Come posso passare una funzione membro di un puntatore a funzione, e quindi come potrei quindi chiamare che puntatore a funzione?

Answer 1

Non è possibile. O si passare un puntatore a un metodo statico o genitore deve anche accettare un puntatore all'oggetto.

Si potrebbe desiderare di guardare boost :: bind e boost :: funzione per questo:

#include <boost/bind.hpp>
#include <boost/function.hpp>
struct Y
{
    void say(void) { std::cout << "hallo!";}

    boost::function<void()> getFunc() { return boost::bind(&Y::say, this); }
};

struct X
{
    //non-boost:
    void (Y::*func)();
    Y* objectY;
    void callFunc() { (objectY->*func)(); }

    //boost version:
    boost::function<void()> f;

};


X x;
Y y;
x.f = boost::bind(&Y::say, boost::ref(y));
x.f = y.getFunc();
x.f();
x.func = &Y::say;
x.objectY = &y; 
x.callFunc();

Answer 2

In risposta alla sua ultima modifica, in modo da formare un puntatore-a-membro, è necessario utilizzare & e classkey::. Non c'è alcun equivalente al nome della funzione di puntatore a funzione di conversione implicita per le funzioni normali.

// not valid:
p.funcPointer3=TestFunc;

// valid:
p.funcPointer3 = &Child::TestFunc;

Per accedere a un membro attraverso un membro puntatore-a-è necessario utilizzare il .* o ->* operatore.

per es.

(this->*p.funcPointer3)();

Answer 3

In realtà possiamo realizzare tutto 3 dei tuoi funcPointer*s in C ++ 11 con l'avvento di bind e Lambda Funzioni . Parliamo di ognuno prima e discutere quello che stanno facendo:

1. funcPointer cerca di chiamare un metodo Child senza di prendere in un oggetto Child, quindi l'oggetto Child avrebbe dovuto essere salvato. L'oggetto bambino potrebbe essere salvato da puntatore: bind(&Child::TestFunc, this) O in C ++ 14 che potrebbero essere salvate per valore: [arg = *this]() mutable { arg.TestFunc(); }
2. funcPointer2 cerca di chiamare un metodo Child con un Parent*. Potremmo fare questo tipo: [](Parent* arg){ static_cast<Child*>(arg)->TestFunc(); } Naturalmente questo non sarebbe più legale di (new Parent)->TestFunc() quindi stiamo assumendo che la Parent* è in realtà una Child*, se erano disposti a fare Parent un polimorfico tipo si potrebbe verificare prima di chiamare nel vostro lambda:

[](Parent* arg) {
    assert(dynamic_cast<Child*>(arg) != nullptr);

    static_cast<Child*>(arg)->TestFunc();
}

3. funcPointer3 cerca di memorizzare un puntatore a un metodo Child, e che già aveva quel lavoro. Hai solo bisogno di utilizzare un oggetto Child chiamare, per esempio: (this->*p.funcPointer3)(). Ma è necessario assegnare funcPointer3 in questo modo: funcPointer3 = &Child::TestFunc, perché se si tenta di fare questo: funcPointer3 = &TestFunc si otterrà l'errore:

  

'&': operazione non valida sull'espressione funzione di membro vincolato

Successivamente, un puntatore a funzione o un puntatore funzione membro non può essere utilizzato per fare riferimento a Tipo della chiusura , quindi avremo bisogno di convertire i puntatori a funzione di function oggetti. (funcPointer3 è solo un puntatore a funzione membro, in modo che non ha bisogno di essere convertito, ma io lo convertirà per dimostrare che un oggetto function possono contiene un puntatore a funzione membro e semplifica la chiamata a: p.funcPointer(this)):

class Parent {
public:
    function<void()> funcPointer;
    function<void(Parent*)> funcPointer2;
    function<void(Child*)> funcPointer3;
};

Ora che abbiamo adattato Parent possiamo facilmente assegnare come dimostrato in 1 , 2 e 3 :

void Child::Do() {
    Parent p;

    p.funcPointer = bind(&Child::TestFunc, this);
    p.funcPointer2 = [](Parent* arg) { static_cast<Child*>(arg)->TestFunc(); };
    p.funcPointer3 = &Child::TestFunc;
    p.funcPointer();
    p.funcPointer2(this);
    p.funcPointer3(this);
}

Probabilmente lo sanno e sono stati solo test, ma avremmo potuto altrettanto facilmente utilizzato i membri del Parent che Child ereditato da come abbiamo potuto creare un nuovo oggetto Parent in Child::Do. Ho intenzione di cambiare che e lanciare il codice in un esempio: http://ideone.com/yD7Rom