Como você passar um ponteiro função membro?

Question

Eu estou tentando passar uma função membro dentro de uma classe para uma função que leva um ponteiro membro da classe função. O problema que estou tendo é que eu não estou certo de como fazer corretamente esta dentro da classe usando a este ponteiro. Alguém tem sugestões?

Aqui está uma cópia da classe que está passando a função de 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;
}
};

O x.SetButton função (...) está contida em outra classe, onde "objeto" é um modelo.

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 alguém tem algum conselho sobre como eu posso enviar corretamente essa função para que eu possa usá-lo mais tarde.

Answer 1

Para chamar uma função membro de ponteiro, você precisa de duas coisas: um ponteiro para o objeto e um ponteiro para a função. Você precisa tanto em 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;
}

Em seguida, você pode chamar a função usando ambos os ponteiros:

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

Não se esqueça de passar o ponteiro para o objeto para 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

Eu recomendo fortemente boost::bind e boost::function para qualquer coisa como isto.

Consulte Pass e chamar uma função membro (boost :: bind / boost :: função?)

Answer 3

Eu sei que este é um tema muito antigo. Mas há uma maneira elegante de lidar com isso com c ++ 11

#include <functional>

declarar o ponteiro função como esta

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

declarar a sua função de seu passar essa coisa em

void SetHandler(Max Handler);

suponha que você passar uma função normal para que você pode usá-lo como normais

SetHandler(&some function);

suponha que você tenha uma função membro

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

em seu código você pode passá-lo usando std::placeholders como este

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

Answer 4

Você não pode ser melhor servido para usar OO padrão. Definir um contrato (classe virtual) e implementar isso em sua própria classe, em seguida, basta passar uma referência a sua própria classe e deixe o receptor chamar a função contrato.

Usando o seu exemplo (que eu renomeado o método 'test2' para '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;
    }
};

No método receptor, você armazena a referência a um ButtonContract, então quando você quer executar a ação do botão apenas chamar o método 'buttonAction' desse objeto ButtonContract armazenado.

Answer 5

No caso raro que acontecer de você estar desenvolvendo com Borland C ++ Builder e não se importa de escrever código específico para esse ambiente de desenvolvimento (isto é, o código que não vai trabalhar com outros compiladores C ++), você pode usar a palavra-chave __closure. Eu encontrei um pequeno artigo sobre o C ++ Builder fechamentos . Eles são destinados principalmente para uso com Borland VCL.

Answer 6

Outros contaram-lhe como fazê-lo corretamente. Mas eu estou surpreso que ninguém lhe disse que este código é realmente perigoso:

this->ButtonFunc = &ButtonFunc;

Desde ButtonFunc é um parâmetro, ele vai sair do escopo quando a função retorna. Você está tomando o seu endereço. Você vai ter um valor do tipo void (object::**ButtonFunc)() ( ponteiro para um ponteiro para uma função membro ) e atribuí-la a this-> ButtonFunc. No momento em que poderiam tentar usar this-> ButtonFunc você tentar acessar o armazenamento do (agora não existente mais) parâmetro local, e seu programa provavelmente iria falhar.

Concordo com a solução da Commodore. Mas você tem que mudar a sua linha para

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

desde ButtonObj é uma ponteiro para objeto.