Cocos2d-x 3.0 新特性- 回调函数的变化

转自：http://blog.youkuaiyun.com/crayondeng/article/details/18767407

在cocos2d-x 2.x版本中的回调函数的用法想必大家都很是熟悉，例如在menu item，call back action中都需要大量的使用到回调函数，但是在使用过程中总是感觉到比较冗余麻烦的，在3.0版本，使用到了C++11 的新特性，改进增加了回到函数的使用形式，其中最令人欣慰的是，可以使用闭包，对于有过iOS开发经验的来说，应该很亲切，就是 block。

下面将通过几个例子详细介绍在3.0版本中回调函数的各种用法。温馨提示：由于用到了C++11中的std::function,std::bind和lambda表达式，所以对此不太了解的可以先看看我之前的这篇有关C++11的一些用法介绍  点击打开链接 。

一、通过 HelloWorldScene 中的 closeItem 开始

在cocos2d-x 2.x 版本中：

[cpp]  view plain copy

1. CCMenuItemImage *pCloseItem = CCMenuItemImage::create(  
2.                                         "CloseNormal.png",  
3.                                         "CloseSelected.png",  
4.                                         this,  
5.                                         menu_selector(HelloWorld::menuCloseCallback));  

在cocos2d-x 3.0 版本中：

[cpp]  view plain copy

1. auto closeItem = MenuItemImage::create(  
2.                                            "CloseNormal.png",  
3.                                            "CloseSelected.png",  
4.                                            CC_CALLBACK_1(HelloWorld::menuCloseCallback, this));  

[cpp]  view plain copy

1. void HelloWorld::menuCloseCallback(Object* pSender)  
2. {  
3.     Director::getInstance()->end();  
4.   
5. #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)  
6.     exit(0);  
7. #endif  
8. }  

注意到在3.0版本中使用到 CC_CALLBACK_1 这样一个宏定义。

[cpp]  view plain copy

1. // new callbacks based on C++11  
2. #define CC_CALLBACK_0(__selector__,__target__, ...) std::bind(&__selector__,__target__, ##__VA_ARGS__)  
3. #define CC_CALLBACK_1(__selector__,__target__, ...) std::bind(&__selector__,__target__, std::placeholders::_1, ##__VA_ARGS__)  
4. #define CC_CALCC_CALLBACK_1(HelloWorld::menuCloseCallback,this)LBACK_2(__selector__,__target__, ...) std::bind(&__selector__,__target__, std::placeholders::_1, std::placeholders::_2, ##__VA_ARGS__)  
5. #define CC_CALLBACK_3(__selector__,__target__, ...) std::bind(&__selector__,__target__, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3 ##__VA_ARGS__)  

原来还有 CC_CALLBACK_0 1 2 3;而其中又有什么区别呢？

1、首先我们看看3.0版本中MenuItemImage的create方法：

[cpp]  view plain copy

1. MenuItemImage * MenuItemImage::create(const std::string& normalImage, const std::string& selectedImage, const ccMenuCallback& callback)  

其中的回调参数是 ccMenuCallback 

[cpp]  view plain copy

1. typedef std::function<void(Object*)> ccMenuCallback  

原来这里使用到了 C++ 中的 function 语法。

注意到 在 CC_CALLBACK_  的宏定义的中使用到的是 C++ 的 bind 语法，怎么不一致了呢？ -- 见下面第四点 function

2、看回 CC_CALLBACK_  的宏定义

原来 CC_CALLBACK_  的宏定义中后面的 0 1 2 3分别表示的是 不事先指定回调函数参数的个数。

例如说 CC_CALLBACK_ 1 表示的是，回调函数中不事先指定参数是一个，而事先指定的回调函数的参数 可以任意多个。

而且要注意到其中 不指定回调函数参数  和  指定回调函数参数  的顺序，注意不事先指定的在前，事先指定的在后。

下面通过例子说明这一点：

假设回调函数：

[cpp]  view plain copy

1. // a selector callback  
2.     void menuCloseCallback(Object* pSender,int a,int b);  

[cpp]  view plain copy

1. void HelloWorld::menuCloseCallback(Object* pSender,int a,int b)  
2. {  
3.     std::cout<<a<<"  "<<b<<std::endl;  
4.     Director::getInstance()->end();  
5.   
6. #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)  
7.     exit(0);  
8. #endif  
9. }  

注意到在回调函数中输出 a b

[cpp]  view plain copy

1. auto closeItem = MenuItemImage::create(  
2.                                            "CloseNormal.png",  
3.                                            "CloseSelected.png",  
4.                                            CC_CALLBACK_1(HelloWorld::menuCloseCallback,this,1,2));  

注意中其中 指定了两个参数 1 2 

运行，在 点击closeItem  的时候，就会输出这两个事先指定的参数 1  2。

那么，不事先指定的参数是在什么时候传入的呢？

[cpp]  view plain copy

1. void MenuItem::activate()  
2. {  
3.     if (_enabled)  
4.     {  
5.         if( _callback )  
6.         {  
7.             _callback(this);  
8.         }  
9.           
10.         if (kScriptTypeNone != _scriptType)  
11.         {  
12.             BasicScriptData data(this);  
13.             ScriptEvent scriptEvent(kMenuClickedEvent,&data);  
14.             ScriptEngineManager::getInstance()->getScriptEngine()->sendEvent(&scriptEvent);  
15.         }  
16.     }  
17. }  

注意到其中的  _callback(this);  对了，这个时候就传入了 这个不事先指定的回调函数参数。

这样，closeItem 的回调函数的 void HelloWorld::menuCloseCallback(Object* pSender,int a,int b) 的三个参数都知道了。

第一个 不事先指定，在menu item调用 activate 的时候，_callback(this) 传入，this 也即是这个 menu item；第二、三个参数是事先指定的 1,2。

3、bind

已经知道  CC_CALLBACK_  的宏定义是 std::bind 那么我们可以直接使用std::bind。

如下：

[cpp]  view plain copy

1. auto closeItem = MenuItemImage::create(  
2.                                            "CloseNormal.png",  
3.                                            "CloseSelected.png",  
4.                                            std::bind(&HelloWorld::menuCloseCallback, this,std::placeholders::_1,1,2));  

4、function

最后就解决上面的一个疑惑。

[cpp]  view plain copy

1. std::function<void(Object*)> func = std::bind(&HelloWorld::menuCloseCallback,this, std::placeholders::_1,1,2);  
2.     auto closeItem = MenuItemImage::create(  
3.                                            "CloseNormal.png",  
4.                                            "CloseSelected.png",  
5.                                            func);  

5、使用lambda表达式

[cpp]  view plain copy

1. auto closeItem = MenuItemImage::create(  
2.                                            "CloseNormal.png",  
3.                                            "CloseSelected.png",  
4.                                            [&](Object *sender){  
5.                                                Director::getInstance()->end();  
6.                                                #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)  
7.                                                exit(0);  
8.                                                #endif  
9.                                            });  

可见使用lambda表达式可以极大的简化代码程序，不需要再定义一个回调函数，直接将在回调中的操作在闭包中体现即可。

二、在cocos2d-x中，还有一个地方是需要大量使用到回调函数的，这就是回调动作：CCCallFunc、CCCallFuncN、CCCallFuncND、CCCallFuncO。

但是这四个回调动作在 3.0 版本中已经都提示 deprecate 了。那么在3.0 版本中已经只剩下 CallFunc 和 CallFuncN.

下面是官方文档中的说明：

• CallFunc can be created with an std::function<void()>
• CallFuncN can be created with an std::function<void(Node*)>
• CallFuncND and CallFuncO were removed since it can be created with simulated with CallFuncN and CallFunc. See ActionsTest.cpp for more examples

其中：CallFuncND 和 CallFuncO 都可以通过 CallFunc 和 CallFuncN 进行实现。

下面通过例子详细的介绍这两个回调动作的用法。

1、CallFunc

[cpp]  view plain copy

1. static CallFunc * create(const std::function<void()>& func);  

关于CallFunc的例子，在文档中已经有体现：

[cpp]  view plain copy

1. // in v2.1  
2. CCCallFunc *action1 = CCCallFunc::create( this, callfunc_selector( MyClass::callback_0 ) );  
3.   
4. // in v3.0 (short version)  
5. auto action1 = CallFunc::create( CC_CALLBACK_0(MyClass::callback_0,this));  
6. auto action2 = CallFunc::create( CC_CALLBACK_0(MyClass::callback_1,this, additional_parameters));  
7.   
8. // in v3.0 (long version)  
9. auto action1 = CallFunc::create( std::bind( &MyClass::callback_0, this));  
10. auto action2 = CallFunc::create( std::bind( &MyClass::callback_1, this, additional_parameters));  
11.   
12. // in v3.0 you can also use lambdas or any other "Function" object  
13. auto action1 = CallFunc::create(  
14.                  [&](){  
15.                      auto s = Director::sharedDirector()->getWinSize();  
16.                      auto label = LabelTTF::create("called:lambda callback", "Marker Felt", 16);  
17.                      label->setPosition(ccp( s.width/4*1,s.height/2-40));  
18.                      this->addChild(label);  
19.                  }  );  

2、CallFuncN

[cpp]  view plain copy

1. static CallFuncN * create(const std::function<void(Node*)>& func);  

注意到该回调动作带有一个Node*参数。特别注意的是回调函数的参数必须是Node*, 不能是其子类，例如Sprite*等，否则会报编译错误。

假设回调函数：

[cpp]  view plain copy

1. void ActionCallFuncN::callback(Node* sender )  

[cpp]  view plain copy

1. auto action = Sequence::create(  
2.        MoveBy::create(2.0f, Point(150,0)),  
3.        CallFuncN::create( CC_CALLBACK_1(ActionCallFuncN::callback, this)),  
4.        NULL);  

[cpp]  view plain copy

1. auto action = Sequence::create(  
2.                                    MoveBy::create(2.0f, Point(150,0)),  
3.                                    CallFuncN::create(std::bind(&ActionCallFuncN::callback,this,std::placeholders::_1)),  
4.                                    NULL);  

[cpp]  view plain copy

1. auto action = Sequence::create(  
2.                                    MoveBy::create(2.0f, Point(150,0)),  
3.                                    CallFuncN::create([&](Node* sender){  
4.                                     //回调动作代码  
5.           
6.                                     }),  
7.                                    NULL);  

受益于C++11的新语法特性 std::bind ；  CallFuncND 和 CallFuncO 都可以通过  CallFunc 和 CallFuncN 进行实现

3、CallFuncND ：回调动作中带有一个Node*参数和一个void*参数

实现过程类似于 CallFuncN  

假设回调函数是 ：void ActionCallFuncND::doRemoveFromParentAndCleanup(Node* sender, bool cleanup)

那么在回调动作中：

CallFuncN::create( CC_CALLBACK_1(ActionCallFuncND::doRemoveFromParentAndCleanup, this, true))

这样就实现了等价于 CallFuncND 的回调动作。

4、CallFuncO ：回调动作中带有一个Object*参数

实现过程类似于 CallFunc 

假设回调函数是： void ActionCallFuncO::callback(Node* node, bool cleanup)

那么在回调动作中：

CallFunc::create( CC_CALLBACK_0(ActionCallFuncO::callback, this, _grossini, true)

这样就实现了等价于 CallFuncO  的回调动作。

三、总结

在新版的回调处理中，采用了C++11中的 std::function 、std::bind 、lambda 表达式，使得回调的处理变得形式多样，代码灵活了，而其中的lambda表达式可以极大的简化回调代码，推荐使用。