Cocos2d-x 3.0 新特性体验（2） 回调函数的变化

移动开发 2018-05-12 10:02:40 阅读次数: 0

在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 版本中：

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

 

在cocos2d-x 3.0 版本中：

1
2
3
4
auto closeItem = MenuItemImage::create(
                                            "CloseNormal.png" ,
                                            "CloseSelected.png" ,
                                            CC_CALLBACK_1(HelloWorld::menuCloseCallback, this ));
1
2
3
4
5
6
7
8
void HelloWorld::menuCloseCallback(Object* pSender)
{
     Director::getInstance()->end();
 
# if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
     exit( 0 );
#endif
}


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

 

 

1
2
3
4
5
// new callbacks based on C++11
#define CC_CALLBACK_0(__selector__,__target__, ...) std::bind(&__selector__,__target__, ##__VA_ARGS__)
#define CC_CALLBACK_1(__selector__,__target__, ...) std::bind(&__selector__,__target__, std::placeholders::_1, ##__VA_ARGS__)
#define CC_CALCC_CALLBACK_1(HelloWorld::menuCloseCallback, this )LBACK_2(__selector__,__target__, ...) std::bind(&__selector__,__target__, std::placeholders::_1, std::placeholders::_2, ##__VA_ARGS__)
#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方法：

 

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

其中的回调参数是 ccMenuCallback

 

 

1
typedef std::function< void (object*)> ccMenuCallback</ void (object*)>

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

 

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

 

2、看回 CC_CALLBACK_ 的宏定义

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

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

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

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

假设回调函数：

 

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

 

 

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

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

 

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

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

 

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

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

 

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

注意到其中的 _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。

如下：

 

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

 

4、function

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

 

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


5、使用lambda表达式

 

 

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

可见使用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 withCallFuncN and CallFunc. See ActionsTest.cpp for more examples 其中：CallFuncND 和 CallFuncO 都可以通过 CallFunc 和 CallFuncN 进行实现。

     

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

    1、CallFunc

     

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

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

     

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

     

     

    2、CallFuncN

     

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

    注意到该回调动作带有一个Node*参数。

    假设回调函数：

     

    1
    void ActionCallFuncN::callback(Node* sender )

     

     

    1
    2
    3
    4
    auto action = Sequence::create(
            MoveBy::create( 2 .0f, Point( 150 , 0 )),
            CallFuncN::create( CC_CALLBACK_1(ActionCallFuncN::callback, this )),
            NULL);
     
    1
    2
    3
    4
    auto action = Sequence::create(
                                        MoveBy::create( 2 .0f, Point( 150 , 0 )),
                                        CallFuncN::create(std::bind(&ActionCallFuncN::callback, this ,std::placeholders::_1)),
                                        NULL);
     
    1
    2
    3
    4
    5
    6
    7
    auto action = Sequence::create(
                                        MoveBy::create( 2 .0f, Point( 150 , 0 )),
                                        CallFuncN::create([&](Node* sender){
                                         //回调动作代码
             
                                         }),
                                        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表达式可以极大的简化回调代码，推荐使用。

  • 转自：http://www.2cto.com/kf/201401/275831.html

猜你喜欢

转载自jiapumin.iteye.com/blog/2059931
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022