Come si passa un puntatore alla funzione membro?

Question

Sto cercando di passare una funzione membro all'interno di una classe a una funzione che accetta un puntatore di classe della funzione membro. Il problema che sto riscontrando è che non sono sicuro di come farlo correttamente all'interno della classe usando questo puntatore. Qualcuno ha suggerimenti?

Ecco una copia della classe che sta passando la funzione membro:

class testMenu : public MenuScreen{
public:

bool draw;

MenuButton<testMenu> x;

testMenu():MenuScreen("testMenu"){
    x.SetButton(100,100,TEXT("buttonNormal.png"),TEXT("buttonHover.png"),TEXT("buttonPressed.png"),100,40,&this->test2);

    draw = false;
}

void test2(){
    draw = true;
}
};

La funzione x.SetButton (...) è contenuta in un'altra classe, dove " oggetto " è un modello.

void SetButton(int xPos, int yPos, LPCWSTR normalFilePath, LPCWSTR hoverFilePath, LPCWSTR pressedFilePath, int Width, int Height, void (object::*ButtonFunc)()) {

    BUTTON::SetButton(xPos, yPos, normalFilePath, hoverFilePath, pressedFilePath, Width, Height);

    this->ButtonFunc = &ButtonFunc;
}

Se qualcuno ha qualche consiglio su come posso inviare correttamente questa funzione in modo da poterla utilizzare in seguito.

Answer 1

Per chiamare una funzione membro tramite puntatore, sono necessari due elementi: un puntatore all'oggetto e un puntatore alla funzione. È necessario sia in MenuButton::SetButton()

template <class object>
void MenuButton::SetButton(int xPos, int yPos, LPCWSTR normalFilePath,
        LPCWSTR hoverFilePath, LPCWSTR pressedFilePath,
        int Width, int Height, object *ButtonObj, void (object::*ButtonFunc)())
{
  BUTTON::SetButton(xPos, yPos, normalFilePath, hoverFilePath, pressedFilePath, Width, Height);

  this->ButtonObj = ButtonObj;
  this->ButtonFunc = ButtonFunc;
}

Quindi puoi invocare la funzione usando entrambi i puntatori:

((ButtonObj)->*(ButtonFunc))();

Non dimenticare di passare il puntatore al tuo oggetto su MenuButton :: SetButton () :

testMenu::testMenu()
  :MenuScreen("testMenu")
{
  x.SetButton(100,100,TEXT("buttonNormal.png"), TEXT("buttonHover.png"),
        TEXT("buttonPressed.png"), 100, 40, this, test2);
  draw = false;
}

Answer 2

Consiglio vivamente boost :: bind e boost :: function per qualcosa del genere.

Vedi Passa e chiama una funzione membro (boost :: bind / boost :: funzione?)

Answer 3

So che questo è un argomento piuttosto vecchio. Ma esiste un modo elegante di gestirlo con c ++ 11

#include <functional>

dichiara il tuo puntatore a funzione in questo modo

typedef std::function<int(int,int) > Max;

dichiara la tua funzione in cui passi questa cosa

void SetHandler(Max Handler);

supponiamo che gli passi una normale funzione per poterla usare normalmente

SetHandler(&some function);

supponi di avere una funzione membro

class test{
public:
  int GetMax(int a, int b);
...
}

nel tuo codice puoi passarlo usando std :: segnaposto come questo

test t;
Max Handler = std::bind(&test::GetMax,&t,std::placeholders::_1,std::placeholders::_2);
some object.SetHandler(Handler);

Answer 4

Non saresti meglio servito per utilizzare OO standard. Definisci un contratto (classe virtuale) e implementalo nella tua classe, quindi passa un riferimento alla tua classe e lascia che il destinatario chiami la funzione di contratto.

Usando il tuo esempio (ho rinominato il metodo 'test2' in 'buttonAction'):

class ButtonContract
{
  public:
    virtual void buttonAction();
}


class testMenu : public MenuScreen, public virtual ButtonContract
{
  public:
    bool draw;
    MenuButton<testMenu> x;

    testMenu():MenuScreen("testMenu")
    {
      x.SetButton(100,100,TEXT("buttonNormal.png"), 
              TEXT("buttonHover.png"), 
              TEXT("buttonPressed.png"), 
              100, 40, &this);
      draw = false;
    }

    //Implementation of the ButtonContract method!
    void buttonAction()
    {
      draw = true;
    }
};

Nel metodo del ricevitore, si memorizza il riferimento a un ButtonContract, quindi quando si desidera eseguire l'azione del pulsante è sufficiente chiamare il metodo "buttonAction" dell'oggetto ButtonContract memorizzato.

Answer 5

Nel raro caso in cui tu stia sviluppando con Borland C ++ Builder e non ti dispiaccia scrivere codice specifico per quell'ambiente di sviluppo (cioè codice che non funzionerà con altri compilatori C ++), puoi usare la parola chiave __closure. Ho trovato un un piccolo articolo sulle chiusure di C ++ Builder . Sono destinati principalmente all'uso con Borland VCL.

Answer 6

Altri ti hanno detto come farlo correttamente. Ma sono sorpreso che nessuno ti abbia detto che questo codice è in realtà pericoloso:

this->ButtonFunc = &ButtonFunc;

Poiché ButtonFunc è un parametro, uscirà dall'ambito quando la funzione ritorna. Stai prendendo il suo indirizzo. Otterrai un valore di tipo void (object :: ** ButtonFunc) () ( puntatore a un puntatore a una funzione membro ) e assegnalo a this- > ButtonFunc. Nel momento in cui proveresti a utilizzare questo pulsante > proveresti ad accedere alla memoria del parametro locale (ora non più esistente) e il tuo programma probabilmente si arresterebbe in modo anomalo.

Sono d'accordo con la soluzione di Commodore. Ma devi cambiare la sua linea in

((ButtonObj)->*(ButtonFunc))();

poiché ButtonObj è un puntatore per obiettare.