我不明白这些功能有何不同

Question

I have callbackType that works if i define the function without a class but when i try to do the same but with a class it just give me an error of conversion.

.h

typedef void(*NclCallback)(NclEvent event, void* userData);
NclCallback callBack;

.cpp

void callBackF(NclEvent event, void* userData){}

EventManager::EventManager(){
    this->callBack = callBackF; //this works,
    this->callBack = callBackFunction; // this doesn't work
    this->callBack = this->callBackFunction; // this doesn't work
}

void EventManager::callBackFunction(NclEvent event, void* userData){}

Answer 1

The difference is that member functions of a class have an implicit first parameter this which points to the instance of the class that the function was invoked with. So the difference between your two functions is that the standalone one takes two parameters while the member function takes three parameters.

To solve this problem, you need to use std::bind to bind the callback to the instance of EventManager on which you want it to be called. Alternately, you can make the callback function static.

Answer 2

A function inside a class requires a this pointer that points to the object the function is being called on. Thus, the signature is extended by an extra T* (in your case EventManager* ) that gets passed. The signatures don't match.

You can use static functions to tell the compiler that this function does not operate on a specific instance. You won't get a this pointer and your code should work. If you do need access to an instance pointer, take a look at std::bind .

Answer 3

You can also use std::function and lambdas to store callbacks:

std::function<void(int, int)> callback;

void f1(int, int) {
  cout << "one" << endl;
}

struct f2 {
  void operator() (int, int) {
    cout << "two" << endl;
  }
};

struct f3 {
  void member(int, int) {
    cout << "three" << endl;
  }
};

int main() {
  callback = f1;
  callback(0,0);
  callback = f2{};
  callback(0,0);
  f3 obj;
  callback = [&obj] (int a, int b) { obj.member(a,b); };
  callback(0,0);
  using namespace std::placeholders;
  callback = std::bind(&f3::member, obj, _1, _2);
  callback(0,0);
  return 0;  
}