类成员函数指针 ->*语法剖析

时间:2022-09-23 08:03:38

在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;
    }