使用类成员的c++回调

您可以使用新的c++ 11标准中的功能，而不是使用静态方法和传递指向类实例的指针:std::function和std::bind:

#include <functional>
class EventHandler
{
    public:
        void addHandler(std::function<void(int)> callback)
        {
            cout << "Handler added..." << endl;
            // Let's pretend an event just occured
            callback(1);
        }
};

addHandler方法现在接受一个std::function参数，并且这个"函数对象"没有返回值，并接受一个整数作为参数。

使用std::bind:

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 << x + private_x << endl;
}

在添加处理程序时需要使用std::bind，因为您需要显式地指定否则隐式的this指针作为参数。如果你有一个独立的函数，你不需要使用std::bind:

void freeStandingCallback(int x)
{
    // ...
}
int main()
{
    // ...
    handler->addHandler(freeStandingCallback);
}

让事件处理程序使用std::function对象，还可以使用新的c++ 11 lambda函数:

handler->addHandler([](int x) { std::cout << "x is " << x << 'n'; });

这里有一个简洁的版本，可以使用类方法回调和常规函数回调。在本例中，为了显示如何处理参数，回调函数接受两个参数:bool和int。

class Caller {
  template<class T> void addCallback(T* const object, void(T::* const mf)(bool,int))
  {
    using namespace std::placeholders; 
    callbacks_.emplace_back(std::bind(mf, object, _1, _2));
  }
  void addCallback(void(* const fun)(bool,int)) 
  {
    callbacks_.emplace_back(fun);
  }
  void callCallbacks(bool firstval, int secondval) 
  {
    for (const auto& cb : callbacks_)
      cb(firstval, secondval);
  }
private:
  std::vector<std::function<void(bool,int)>> callbacks_;
}
class Callee {
  void MyFunction(bool,int);
}
//then, somewhere in Callee, to add the callback, given a pointer to Caller `ptr`
ptr->addCallback(this, &Callee::MyFunction);
//or to add a call back to a regular function
ptr->addCallback(&MyRegularFunction);

这将c++ 11特定的代码限制为addCallback方法和类Caller中的私有数据。至少对我来说，这将实现它时犯错误的可能性降到最低。

注意，在c++ 20的bind_front中，你可以将类成员函数的add_callback简化为:

      template<class T> void addCallback(T* const object, void(T::* const mf)(bool,int))
      {
        callbacks_.emplace_back(std::bind_front(mf, object));
      }

你要做的是创建一个接口来处理这些代码，并且你所有的类都实现了这个接口。

class IEventListener{
public:
   void OnEvent(int x) = 0;  // renamed Callback to OnEvent removed the instance, you can add it back if you want.
};

class MyClass :public IEventListener
{
    ...
    void OnEvent(int x); //typically such a function is NOT static. This wont work if it is static.
};
class YourClass :public IEventListener
{

请注意，为了使其工作，"Callback"函数是非静态的，我认为是一个改进。如果您希望它是静态的，您需要按照JaredC对模板的建议来做。

上面代码的完整工作示例....对于c++ 11:

#include <stdlib.h>
#include <stdio.h>
#include <functional>
#if __cplusplus <= 199711L
  #error This file needs at least a C++11 compliant compiler, try using:
  #error    $ g++ -std=c++11 ..
#endif
using namespace std;
class EventHandler {
    public:
        void addHandler(std::function<void(int)> callback) {
            printf("nHandler added...");
            // Let's pretend an event just occured
            callback(1);
        }
};

class MyClass
{
    public:
        MyClass(int);
        // Note: No longer marked `static`, and only takes the actual argument
        void Callback(int x);
    private:
        EventHandler *pHandler;
        int private_x;
};
MyClass::MyClass(int value) {
    using namespace std::placeholders; // for `_1`
    pHandler = new EventHandler();
    private_x = value;
    pHandler->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
    printf("nResult:%dnn", (x+private_x));
}
// Main method
int main(int argc, char const *argv[]) {
    printf("nCompiler:%ldn", __cplusplus);
    new MyClass(5);
    return 0;
}

// where $1 is your .cpp file name... this is the command used:
// g++ -std=c++11 -Wall -o $1 $1.cpp
// chmod 700 $1
// ./$1

输出应该是:

Compiler:201103
Handler added...
Result:6

MyClass和YourClass都可以从具有抽象(虚拟)Callback方法的SomeonesClass派生。您的addHandler将接受类型为SomeonesClass和MyClass的对象，YourClass可以覆盖Callback，以提供回调行为的特定实现。

如果你有不同参数的回调，你可以使用模板如下:
//编译:c++ -std=c++11 myTemplatedCPPcallbacks.cpp -o myTemplatedCPPcallbacksApp

#include <functional>     // c++11
#include <iostream>        // due to: cout

using std::cout;
using std::endl;
class MyClass
{
    public:
        MyClass();
        static void Callback(MyClass* instance, int x);
    private:
        int private_x;
};
class OtherClass
{
    public:
        OtherClass();
        static void Callback(OtherClass* instance, std::string str);
    private:
        std::string private_str;
};
class EventHandler
{
    public:
        template<typename T, class T2>
        void addHandler(T* owner, T2 arg2)
        {
            cout << "nHandler added..." << endl;
            //Let's pretend an event just occured
            owner->Callback(owner, arg2);
         }   
};
MyClass::MyClass()
{
    EventHandler* handler;
    private_x = 4;
    handler->addHandler(this, private_x);
}
OtherClass::OtherClass()
{
    EventHandler* handler;
    private_str = "moh ";
    handler->addHandler(this, private_str );
}
void MyClass::Callback(MyClass* instance, int x)
{
    cout << " MyClass::Callback(MyClass* instance, int x) ==> " 
         << 6 + x + instance->private_x << endl;
}
void OtherClass::Callback(OtherClass* instance, std::string private_str)
{
    cout << " OtherClass::Callback(OtherClass* instance, std::string private_str) ==> " 
         << " Hello " << instance->private_str << endl;
}
int main(int argc, char** argv)
{
    EventHandler* handler;
    handler = new EventHandler();
    MyClass* myClass = new MyClass();
    OtherClass* myOtherClass = new OtherClass();
}