¿Cómo se pasa un puntero de función miembro?

Recomiendo encarecidamente boost::bind y boost::function para algo como esto.

Ver Pasar y llamar a una función miembro (boost:: bind / boost::function?)

Sé que este es un tema bastante antiguo. Pero hay una manera elegante de manejar esto con c++11

#include <functional>

Declare su puntero de función así

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

Declare su la función su pase esta cosa en

void SetHandler(Max Handler);

Supongamos que le pasa una función normal, puede usarla como normal

SetHandler(&some function);

Supongamos que tiene una función miembro

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

En tu código puedes pasarlo usando std::placeholders así

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

No sería mejor que usaras OO estándar. Defina un contrato (clase virtual) e implemente eso en su propia clase, luego simplemente pase una referencia a su propia clase y deje que el receptor llame a la función de contrato.

Usando tu ejemplo (he renombrado el método 'test2' a '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;
    }
};

En el método receiver, almacena la referencia a un ButtonContract, luego, cuando desee realizar la acción del botón, simplemente llame al método' buttonAction ' de ese almacenado Objeto ButtonContract.

En el raro caso de que esté desarrollando con Borland C++Builder y no le importe escribir código específico para ese entorno de desarrollo (es decir, código que no funcionará con otros compiladores de C++), puede usar la palabra clave __closure. Encontré un pequeño artículo sobre C++Builder closures. Están destinados principalmente para su uso con Borland VCL.

Otros te han dicho cómo hacerlo correctamente. Pero me sorprende que nadie te haya dicho que este código es realmente peligroso:

this->ButtonFunc = &ButtonFunc;

Dado que ButtonFunc es un parámetro, saldrá del ámbito cuando la función regrese. Estás tomando su dirección. Obtendrá un valor de tipo void (object::**ButtonFunc)() (puntero a un puntero a una función miembro) y asígnelo a this - >ButtonFunc. En el momento en que intentaría usar esto - > ButtonFunc, intentaría acceder al almacenamiento del local (que ya no existe). parámetro, y su programa probablemente se bloquearía.

Estoy de acuerdo con la solución de Commodore. Pero tienes que cambiar su línea a

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

Puesto que ButtonObj es un puntero a objeto.