Cocos2d-x 细说回调函数

cocos2d-x中有大量的回调函数的应用，主要有以下几类，看下CCObject.h中的定义

typedef void (CCObject::*SEL_SCHEDULE)(float);// 用来调update  
typedef void (CCObject::*SEL_CallFunc)();// 用来自定义无参回调  
typedef void (CCObject::*SEL_CallFuncN)(CCNode*);// 带执行者回调  
typedef void (CCObject::*SEL_CallFuncND)(CCNode*, void*); // 带一个自定参数的回调  
typedef void (CCObject::*SEL_CallFuncO)(CCObject*);  
typedef void (CCObject::*SEL_MenuHandler)(CCObject*);  
typedef void (CCObject::*SEL_EventHandler)(CCEvent*);  
typedef int (CCObject::*SEL_Compare)(CCObject*);  
  
#define schedule_selector(_SELECTOR) (SEL_SCHEDULE)(&_SELECTOR)  
#define callfunc_selector(_SELECTOR) (SEL_CallFunc)(&_SELECTOR)  
#define callfuncN_selector(_SELECTOR) (SEL_CallFuncN)(&_SELECTOR)  
#define callfuncND_selector(_SELECTOR) (SEL_CallFuncND)(&_SELECTOR)  
#define callfuncO_selector(_SELECTOR) (SEL_CallFuncO)(&_SELECTOR)  
#define menu_selector(_SELECTOR) (SEL_MenuHandler)(&_SELECTOR)  
#define event_selector(_SELECTOR) (SEL_EventHandler)(&_SELECTOR)  
#define compare_selector(_SELECTOR) (SEL_Compare)(&_SELECTOR) 

本质上，就是函数指针的应用。

但是，我们知道，在C中，函数指针是很普遍的应用。一般函数的函数名就是指针，不过是常量，再定义一个函数指针就是一个变量，这个变量可以指向这一类函数的地址。

比如：

typedef void (*func)(int x);  
void up(int s);  
func f= up;  
f(3); 

func是个函数指针类型：返回值是void，参数是一个int的函数。所以func的变量可以指向所有这一类的函数。
这是C风格的函数指针。但是在cocos2d-x中的回调，虽然还是函数指针，但已经有所区别。准确点说应该是成员函数指针。那么这普通的函数指针还可以来调成员函数吗？呵呵，如果能的话我就不用写这篇文章了。
C风格的函数指针要想调用成员函数，那么这个成员函数如果是static的也可以（为什么静态函数就可以，呵呵）。但是这样的话就会破坏类的结构。看cocos2d-x的实现也不是这样的。
这里说cocos2d-x的实现方式：
看上面的定义，如：typedef void (CCObject::*SEL_MenuHandler)(CCObject*)；
看这个就应该大致可以知道它的实现了。
这个定义有点不一样，就是这个函数是CCObject的成员函数。这就是成员函数指针的定义。
大家知道，成员函数不能像普通C风格的函数那样调用，因为每个成员函数需要知道是哪个对象实例调用它的，隐含有一个this指针。这也解释了为什么静态函数可以用C风格的函数指针来回调，因为静态函数不需要对象实例就可以调用，呵呵。
既然定义成员函数指针，那么要用这个指针变量来调用回调函数，还需不需要对象实例呢。毫无疑问，还是需要的。
所以还必须有一个回调对象，CCObject *m_pListener。
这样调用: 

(m_pListener->*m_pSelector)(CCObject *param);  

下面给出一个demo示例：

#include <iostream>
using namespace std;

// 基类
class Person
{

public:
    void getName(string name);
};
void Person::getName(string name)
{
    cout<<name<<endl;
}

// 定义成员函数指针
typedef void (Person::*SEL_CallFun)(string str);

// 派生类
class Student : public Person
{
private:
    string m_name;
    int m_age;

public:
    Student(string name, int age);
    ~Student();

// 回调方法
    void callBack(string str);

// say方法，要调用回调函数。
    void say();

protected:
// 回调的执行者
    Person *m_pListen;

// 回调函数指针
    SEL_CallFun m_pfnSelectior;
};


Student::Student(string name, int age)
{
    this->m_name = name;
    this->m_age = age;
}

Student::~Student()
{
}

void Student::say()
{
    cout<<"Hi this is a Student"<<endl;

// 回调函数指针赋值。需要强转成 SEL_CallFun
    m_pfnSelectior = (SEL_CallFun)(&Student::callBack);

// 回调的执行对象，传this
    m_pListen = this;

//回调的执行对象先执行其自身Person的方法
    m_pListen->getName(m_name);

// 调用回调，执行Student中的方法，参数是个string
    (m_pListen->*m_pfnSelectior)(m_name);
}

// 成员函数，要回调的函数
void Student::callBack(string str)
{
    cout<<"My name is "
        << str<<endl
        << "age is "
        <<m_age<<endl;
}
int main()
{
    Student *a = new Student("Join",20);
    a->say();
    return 0;
}

运行结果：

说明：

上面的代码中创建了两个类，一个是Person类，另一个是Student类。

在Student类中有一个Person类对象，在say方法中使用这个person对象回调Student类中的callBack方法。

运行结果中：

第二行：Join 是Person类对象调用自身方法getName()

第三四行： 是Person类对象回调Student类中的callBack()方法。