【转】cocos2d-x游戏开发(八)各类构造器

欢迎转载：http://blog.csdn.net/fylz1125/article/details/8521997

这篇写cocos2d-x的构造器。

cocos2d-x引入自动释放机制后，创建的对象就不需要我们像C++编程那样自己delete了。但是怎么让自己的类也能保持cocos2d-x的风格呢？或者说怎么样才能让自己的类实例也能自动释放。

在cocos2d-x里面大量用到了一个叫create()方法(2.1.0版本)。几乎所有的实体类都会用这个create函数来产生实例而不是他们的构造函数。

看看CCSprite的create()函数

[cpp] view plaincopyprint?

1. CCSprite* CCSprite::create() 
2. { 
3.     CCSprite *pSprite = new CCSprite();//调用构造函数，产生对象
4. if (pSprite && pSprite->init()) // 创建对象成功并且其init函数返回true则添加到自动释放池
5.     { 
6.         pSprite->autorelease(); 
7. return pSprite; 
8.     } 
9.     CC_SAFE_DELETE(pSprite); // 安全释放
10. return NULL; 
11. } 

看到了，create函数里面实质上做了两件事：1.调用构造函数 2.init()成功则添加到自动释放池。

然后看init（）函数，就是自己的一些初始化工作了。

对于这个结构大家要非常熟悉，几乎可以说是一个套路。

这个二阶段构造用的很多，为了简化代码提高效率，cocos2d-x有个函数宏专门来干这个活：

[cpp] view plaincopyprint?

1. #define CREATE_FUNC(__TYPE__)
2. static __TYPE__* create()  
3. {  
4.     __TYPE__ *pRet = new __TYPE__();  
5. if (pRet && pRet->init())  
6.     {  
7.         pRet->autorelease();  
8. return pRet;  
9.     }  
10. else  
11.     {  
12. delete pRet;  
13.         pRet = NULL;  
14. return NULL;  
15.     }  
16. } 

这个跟上面CCSprite的create函数很像啊。结构几乎是一样的。

所以我们自己的类只需要用这个宏定义，然后实现init()函数就可以了。用的时候直接调用create()函数。

比如我写Ship：

[cpp] view plaincopyprint?

1. #ifndef __MoonWarriorsx__Ship__
2. #define __MoonWarriorsx__Ship__
4. #include "cocos2d.h"
5. #include "UnitSprite.h"
6. USING_NS_CC; 
8. class Ship : public UnitSprite{ 
9. private: 
10. // 速度
11. int m_speed; 
13. // 子弹速度
14. int m_bulletSpeed; 
16. // 生命值
17. int m_HP; 
19. // 子弹类型
20. int m_bulletTypeValue; 
22. // 子弹威力
23. int m_bulletPowerValue; 
25. // 是否在投掷炸弹
26. bool m_throwBombing; 
28. // 是否可被攻击
29. bool m_canBeAttack; 
31. bool m_isThrowBomb; 
32. int m_zOder; 
34. // 最大子弹威力
35. int m_maxBulletPowerValue; 
37. // 出现的初始位置
38.     CCPoint m_appearPosition; 
39. int m_hurtColorLife; 
40. bool m_active; 
42. public: 
43.     Ship(); 
44.     ~Ship(); 
46. // 被攻击使能
47. void makeAttack(CCNode *pSender); 
49. // 更新
50. virtual void update(float dt); 
52. // 射击
53. void shoot(float dt); 
55. // 初始化
56. virtual bool init(); 
58. // 被攻击，受伤
59. virtual void hurt(); 
61. // 销毁飞船
62. virtual void destroy(); 
64. // 获取生存状态
65. virtual bool isActive(); 
67. // 碰撞矩形
68. virtual CCRect collideRect(); 
69. int getZoder(); 
71. // 构造器
72.     CREATE_FUNC(Ship); 
73. }; 
75. #endif /* defined(__MoonWarriorsx__Ship__) */

然后构造函数只带了一个初始化列表赋初值，没干别的事情。接着实现init()函数，所有初始化工作都在这里实现：

[cpp] view plaincopyprint?

1. bool Ship::init() 
2. { 
3. // super init first
4. if ( !CCSprite::init() ) 
5.     { 
6. return false; 
7.     } 
10. // init life
11.     CCTexture2D * shipTextureCache = CCTextureCache::sharedTextureCache()->addImage(s_ship01); 
12.     CCRect rec = CCRectMake(0, 0, 60, 38); 
13. this->initWithTexture(shipTextureCache,  rec); 
16. this->setPosition(m_appearPosition); 
19. // set frame
20.     CCSpriteFrame *frame0 = CCSpriteFrame::createWithTexture(shipTextureCache, CCRectMake(0, 0, 60, 38)); 
21.     CCSpriteFrame *frame1 = CCSpriteFrame::createWithTexture(shipTextureCache, CCRectMake(60, 0, 60, 38)); 
23.     CCArray *animFrames = CCArray::create(); 
24.     animFrames->addObject(frame0); 
25.     animFrames->addObject(frame1); 
27. // ship animate
28. // 这个方法有差异
29.     CCAnimation *animation = CCAnimation::createWithSpriteFrames(animFrames, 0.1); 
30.     CCAnimate *animate = CCAnimate::create(animation); 
31. this->runAction(CCRepeatForever::create(animate)); 
33. // 子弹发射
34. this->schedule(schedule_selector(Ship::shoot), 0.16); 
36. // revive effect
37. this->m_canBeAttack = false; 
38.     CCSprite *ghostSprite = CCSprite::createWithTexture(shipTextureCache, CCRectMake(0, 45, 60, 38)); 
39.     ccBlendFunc cbl = {GL_SRC_ALPHA, GL_ONE}; 
40.     ghostSprite->setBlendFunc(cbl); 
41.     ghostSprite->setScale(8); 
42.     ghostSprite->setPosition(ccp(this->getContentSize().width / 2, 12)); 
43. this->addChild(ghostSprite, 3000, 99999); 
44.     ghostSprite->runAction(CCScaleTo::create(0.5, 1, 1)); 
46. // 闪烁动画
47.     CCBlink *blinks = CCBlink::create(3, 9); 
49. // 回调，攻击使能
50. // 带执行者回调，谁执行Action传谁。这里是this，所以传的就是this
51.     CCCallFuncN *makeBeAttack = CCCallFuncN::create(this, callfuncN_selector(Ship::makeAttack)); 
53. this->runAction(CCSequence::create(CCDelayTime::create(0.5), blinks, makeBeAttack, NULL)); 
54. return true; 
55. } 

init函数要先调用super的init(),然后写自己的东西。

这样的二阶段构造有个好处，就是将自动释放封装起来了。因为这个create函数是个static的，创建对象成功且初始化成功就将其添加到自动释放池，然后返回对象实例。你通过create获得对象后不用管它的释放问题。

当然，你也可以标新立异，不一定就按这个来。不过关键一点是，不管你怎么构造你的实例，要确保成功并将其加到自动释放池。比如我有个子弹类不是用create创建实例的，其使用如下：

[cpp] view plaincopyprint?

1. Bullet *bullet_a = new Bullet(m_bulletSpeed, "W1.png", 1); 
2. if (bullet_a) { 
3.         bullet_a->autorelease();// 添加到自动释放池
4.         play_bullet->addObject(bullet_a); 
5. this->getParent()->addChild(bullet_a, bullet_a->m_zorder, 901); 
6.         bullet_a->setPosition(ccp(position.x + offset, position.y + 3 + contentSize.height * 0.3)); 
8.     }else{ 
9. delete bullet_a; 
10.         bullet_a = 0; 
11.     } 

看，自己的构造函数，还要自己添加自动释放池。一看就很乱。其实这个也可以封装起来，自己实现create函数，不用那个宏定义，后续改下。

这里有一点不一样，就是CCScene的构造。

coco2d-x里面导演执行的单元是CCScene，就是场景。一个场景里面会添加很多CCLayer，即层。层里面又会添加很多元素，比如CCSprite，CCMenu等。那么场景如何构造呢？

demo里面是这一做的，在主Layer里面定义一个static的函数scene(),返回一个CCScene对象，例如：

[cpp] view plaincopyprint?

1. CCScene* HelloWorld::scene() 
2. { 
3. // 'scene' is an autorelease object
4.     CCScene *scene = CCScene::create(); 
6. // 'layer' is an autorelease object
7.     HelloWorld *layer = HelloWorld::create(); 
9. // add layer as a child to scene
10.     scene->addChild(layer); 
12. // return the scene
13. return scene; 
14. } 

他在这个函数里面将主Layer构造出来，然后添加到场景里面。注意，所有create函数构造的对象都是一个autorelease的对象。

然后执行场景：

[cpp] view plaincopyprint?

1. // create a scene. it's an autorelease object
2.    CCScene *pScene = HelloWorld::scene(); 
4. // run
5.    pDirector->runWithScene(pScene); 

看，封装好了，代码多清晰。

好了，就这么多，打完收工。