类成员函数指针 ->*语法剖析
在cocos2d-x中，经常会出现这样的调用，如 ->*，这个是什么意思呢，如下面得这个例子：
，
其实这是对类的成员函数指针的调用，在cocos2dx中，这种形式多用于回调函数的调用。如我们经常用到的循环函数
schedule( CC_SCHEDULE_SELECTOR(PauseTest::unpause), 3);
这个意思就是每隔3秒，执行一下unpause方法，这里就用到了成员函数指针，先看下CC_SCHEDULE_SELECTOR的宏定义
#define CC_SCHEDULE_SELECTOR(_SELECTOR) static_cast<cocos2d::SEL_SCHEDULE>(&_SELECTOR)
就是把传入的函数，然后取其地址，转换为 SEL_SCHEDULE，那么SEL_SCHEDULE是什么呢，转到其定义处，为
typedef void (Ref::*SEL_SCHEDULE)(float);
就是说他就是一个指向参数为float，返回值为void 的函数指针，注意他和一般c语言的函数指针不同的是，前面加了作用域Ref，在后面会讲解一般函数指针和类函数指针的不同，这里先看作用域为什么是Ref，以为cocos2d所有的类都继承自Ref，所以只要是cocos2d的类，就可以作为SEL_SCHEDULE的target，深入到schedule( CC_SCHEDULE_SELECTOR(PauseTest::unpause), 3); 的里面，就会发现，是这么调用的
，_selector就是回到函数的地址，_target就是要调用这个回调函数的基类为Ref的对象指针，当每次循环的时候，就会这么调用
从而实现了指定的target进行函数的回调.
现在用一个demo简单演示一下他的用法
namespace AB {
class A ;
typedef void (A::*SEL_CallJinLei)();
class A
{
public:
A(){}
virtual void testA();
};
void A::testA(){
printf("A的testA");
}
class ChildrenA: public A{
public:
virtual void testA(){
printf("ChildrenA的testA");
}
};
class B
{
public:
B(){
}
B(A*target,SEL_CallJinLei selector){
_target=target;
_selector=selector;
}
A *_target;
SEL_CallJinLei _selector;
void testB(){
(_target->*_selector)();
}
};
}
void main(){
using namespace AB;
AB::A *aaa=new A();
ChildrenA *aaa2=new ChildrenA();
B *bbb=new B(aaa,static_cast<AB::SEL_CallJinLei>(&A::testA));
bbb->testB();
B *bbb2=new B(aaa2,static_cast<AB::SEL_CallJinLei>(&ChildrenA::testA));
bbb2->testB();
}
Class A和Class ChildrenA都是我们指的target，他们有成员函数指针，当确定了函数指针的指向，就可以用target来调用了，
通过main中的调用也可以看出， Class A和Class ChildrenA都可以使用
SEL_CallJinLei，也就是实现了多态特性
在cocos2dx中应用也就是 testB就是执行了某些逻辑之后，触发的方法，如scheduler中的trigger，触发之后，就会调用target->*函数指针，从而实现了target的回调方法
下面是解释一般函数指针和成员函数指针的区别，这个网上也比较多了，这里引用一篇，
原文地址为http://www.jb51.net/article/40718.htm
函数指针是通过指向函数的指针间接调用函数。函数指针可以实现对参数类型、参数顺序、返回值都相同的函数进行封装，是多态的一种实现方式。由于类的非静态成员函数中有一个隐形的this指针，因此，类的成员函数的指针和一般函数的指针的表现形式不一样。
1、指向一般函数的指针
函数指针的声明中就包括了函数的参数类型、顺序和返回值，只能把相匹配的函数地址赋值给函数指针。为了封装同类型的函数，可以把函数指针作为通用接口函数的参数，并通过函数指针来间接调用所封装的函数。
下面是一个指向函数的指针使用的例子。
#include <iostream.h>
/*指向函数的指针*/
typedef int (*pFun)(int, int);
int Max(int a, int b)
{
return a > b ? a : b;
}
int Min(int a, int b)
{
return a < b ? a : b;
}
/*通用接口函数，实现对其他函数的封装*/
int Result(pFun fun, int a, int b)
{
return (*fun)(a, b);
}
void main()
{
int a = 3;
int b = 4;
cout<<"Test function pointer: "<<endl;
cout<<"The maximum number between a and b is "<<Result(Max, a, b)<<endl;
cout<<"The minimum number between a and b is "<<Result(Min, a, b)<<endl;
}
2、指向类的成员函数的指针
类的静态成员函数采用与一般函数指针相同的调用方式，而受this指针的影响，类的非静态成员函数与一般函数指针是不兼容的。而且，不同类的this指针是不一样的，因此，指向不同类的非静态成员函数的指针也是不兼容的。指向类的非静态成员函数的指针，在声明时就需要添加类名。
下面是一个指向类的成员函数的指针的使用的例子，包括指向静态和非静态成员函数的指针的使用。
#include <iostream.h>
class CA;
/*指向类的非静态成员函数的指针*/
typedef int (CA::*pClassFun)(int, int);
/*指向一般函数的指针*/
typedef int (*pGeneralFun)(int, int);
class CA
{
public:
int Max(int a, int b)
{
return a > b ? a : b;
}
int Min(int a, int b)
{
return a < b ? a : b;
}
static int Sum(int a, int b)
{
return a + b;
}
/*类内部的接口函数，实现对类的非静态成员函数的封装*/
int Result(pClassFun fun, int a, int b)
{
return (this->*fun)(a, b);
}
};
/*类外部的接口函数，实现对类的非静态成员函数的封装*/
int Result(CA* pA, pClassFun fun, int a, int b)
{
return (pA->*fun)(a, b);
}
/*类外部的接口函数，实现对类的静态成员函数的封装*/
int GeneralResult(pGeneralFun fun, int a, int b)
{
return (*fun)(a, b);
}
void main()
{
CA ca;
int a = 3;
int b = 4;
cout<<"Test nonstatic member function pointer from member function:"<<endl;
cout<<"The maximum number between a and b is "<<ca.Result(CA::Max, a, b)<<endl;
cout<<"The minimum number between a and b is "<<ca.Result(CA::Min, a, b)<<endl;
cout<<endl;
cout<<"Test nonstatic member function pointer from external function:"<<endl;
cout<<"The maximum number between a and b is "<<Result(&ca, CA::Max, a, b)<<endl;
cout<<"The minimum number between a and b is "<<Result(&ca, CA::Min, a, b)<<endl;
cout<<endl;
cout<<"Test static member function pointer: "<<endl;
cout<<"The sum of a and b is "<<GeneralResult(CA::Sum, a, b)<<endl;
}
