c retorno de chamada usando o membro da classe com implementação genérica

A pergunta original teve como objetivo criar um mecanismo genérico de manipulação de eventos que funcionasse de forma consistente em diferentes classes. Em vez de confiar nos métodos estáticos e passar em torno dos ponteiros das instâncias de classe, uma abordagem C mais moderna pode ser empregada usando o manipulador de eventos STD :: e std :: bind. Um objeto de função representa uma entidade chamada que pode ser passada como um ponteiro de função regular. O método do manipulador de eventos Addhandler pega uma função std :: { público: Void AddHandler (STD :: function retorno de chamada) { cout

vinculando funções específicas

para vincular um método de classe específico ao manipulador de eventos, std :: bind é usado. std :: bind especifica o ponteiro e a função a ser chamado quando o evento é acionado.

class EventHandler
{
public:
    void addHandler(std::function callback)
    {
        cout  
 funções independentes e funções lambda 
 
 se o retorno de chamada for uma função independente sem um contexto de classe, std :: bind não é necessário.
{
    // ...
}

int main ()
{
    // ...
    manipulador-> addHandler (FreestingCallback);
} 
 
class MyClass
{
public:
    MyClass();

    // Note: No longer marked `static`, and only takes the actual argument
    void Callback(int x);
private:
    int private_x;
};

MyClass::MyClass()
{
    using namespace std::placeholders; // for `_1`

    private_x = 5;
    handler->addHandler(std::bind(&MyClass::Callback, this, _1));
}

void MyClass::Callback(int x)
{
    // No longer needs an explicit `instance` argument,
    // as `this` is set up properly
    cout  
 handler-> addHandler ([] (int x) {std :: cout