cocos2d-x的内存管理和CCObject类

最新推荐文章于 2020-12-07 23:15:29 发布
最新推荐文章于 2020-12-07 23:15:29 发布
阅读量754 收藏
点赞数
分类专栏： cocos2d-x 文章标签： cocos2d-x
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kingabcde/article/details/26541483
版权
本文探讨了cocos2d-x的内存管理机制，源自于cocos2d并通过引用计数控制。重点分析了基类CCObject以及CCAutoreleasePool的角色。通过实例展示了对象创建、autorelease和release的过程，说明了内存回收池的工作原理，强调了'谁管理，谁负责释放'的原则。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在这里要先明白cocos2d-x内存管理的来源。因为cocos2d-x是将cocos2d重写了一遍，内存管理也是和cocos2d一样，通过引用计数来控制。其实现是在cocos2d-x的基类CCObject中，所以要弄懂cocos2d-x的内存管理，一定会跟CCObject类打交道。所以可以从CCObject类下手。

class CC_DLL CCObject : public CCCopying
{
public:
    // object id, CCScriptSupport need public m_uID
	//与脚本相关，略过
    unsigned int        m_uID;
    // Lua reference id
    //与脚本相关，略过
    int                 m_nLuaID;
protected:
    // count of references
    //引用计数
    unsigned int        m_uReference;
    // count of autorelease
    //在内存回收池的引用次数，也就是调用一次autorelease这个值加1
    unsigned int        m_uAutoReleaseCount;
public:
    //构造
    CCObject(void);
    /**
     *  @lua NA
     */
    //析构
    virtual ~CCObject(void);
    //引用计数减一，为0回收内存
    void release(void);
    //引用计数加1
    void retain(void);
    //把当前对象加入到内存回收池中
    CCObject* autorelease(void);
    //拷贝
    CCObject* copy(void);
    //是否单引用
    bool isSingleReference(void) const;
    //返回当前的引用计数
    unsigned int retainCount(void) const;
    //是否是同一个对象
    virtual bool isEqual(const CCObject* pObject);
    //实现观察者观察CCObject对象
    virtual void acceptVisitor(CCDataVisitor &visitor);
    //更新
    virtual void update(float dt) {CC_UNUSED_PARAM(dt);};
    //声明CCAutoreleasePool为友元类
    friend class CCAutoreleasePool;
};
再看其实现： 

CCObject::CCObject(void)
: m_nLuaID(0)
, m_uReference(1) // 当对象被创建时，应用计数初始化为1，这样便能保证该对象至少能存活一帧
, m_uAutoReleaseCount(0)
{
    static unsigned int uObjectCount = 0;

    m_uID = ++uObjectCount;//与脚本相关，略过
}

CCObject::~CCObject(void)
{
    // if the object is managed, we should remove it
    // from pool manager
    if (m_uAutoReleaseCount > 0)//如果当该对象被销毁时，仍存在于内存回收池中，那么内存回收池清掉该对象
    {
        CCPoolManager::sharedPoolManager()->removeObject(this);
    }
    
    // if the object is referenced by Lua engine, remove it
    //下面与脚本引擎相关，略过
    if (m_nLuaID)
    {
        CCScriptEngineManager::sharedManager()->getScriptEngine()->removeScriptObjectByCCObject(this);
    }
    else
    {
        CCScriptEngineProtocol* pEngine = CCScriptEngineManager::sharedManager()->getScriptEngine();
        if (pEngine != NULL && pEngine->getScriptType() == kScriptTypeJavascript)
        {
            pEngine->removeScriptObjectByCCObject(this);
        }
    }
}

CCObject* CCObject::copy()
{
	//拷贝，空实现
    return copyWithZone(0);
}

void CCObject::release(void)
{
    CCAssert(m_uReference > 0, "reference count should greater than 0");
    //引用计数减1
    --m_uReference;

    if (m_uReference == 0)//如果引用计数为0，则删除该对象
    {
        delete this;
    }
}

void CCObject::retain(void)
{
    CCAssert(m_uReference > 0, "reference count should greater than 0");
    //引用计数加1
    ++m_uReference;
}

CCObject* CCObject::autorelease(void)
{
	//加入到自动回收池中
    CCPoolManager::sharedPoolManager()->addObject(this);
    return this;
}

bool CCObject::isSingleReference(void) const
{
	//若果引用计数为1，则表明当前对象是单引用
    return m_uReference == 1;
}

unsigned int CCObject::retainCount(void) const
{
	//返回引用计数
    return m_uReference;
}

bool CCObject::isEqual(const CCObject *pObject)
{
	//判断是否是同一个对象
    return this == pObject;
}

void CCObject::acceptVisitor(CCDataVisitor &visitor)
{
	//调用观察者的visitObject观察该对象
    visitor.visitObject(this);
}

再看下CCAutoreleasePool的头文件，里面有两个类

//内存回收池类
class CC_DLL CCAutoreleasePool : public CCObject
{
	//内存回收池中对象
    CCArray*    m_pManagedObjectArray;    
public:
    //构造
    CCAutoreleasePool(void);
    //析构
    ~CCAutoreleasePool(void);
    //增加一个对象到回收池中
    void addObject(CCObject *pObject);
    //在回收池中移除一个对象
    void removeObject(CCObject *pObject);
    //清空回收池中的所有对象
    void clear();
};

/**
 * @js NA
 * @lua NA
 */
//内存回收池管理类
class CC_DLL CCPoolManager
{
	//存放回收池的栈
    CCArray*    m_pReleasePoolStack;
    //内存回收池
    CCAutoreleasePool*                    m_pCurReleasePool;
    //获取当前的内存回收池
    CCAutoreleasePool* getCurReleasePool();
public:
    //构造
    CCPoolManager();
    //析构
    ~CCPoolManager();
    //清空所管理的回收池中的所有对象
    void finalize();
    //把一个内存回收池压栈
    void push();
    //把一个内存回收池出栈
    void pop();
    //把一个对象从当前所管理的回收池中移除掉
    void removeObject(CCObject* pObject);
    //把一个对象加到当前所管理的回收池中
    void addObject(CCObject* pObject);
    //获取回收池的管理对象
    static CCPoolManager* sharedPoolManager();
    //释放回收池管理对象的资源
    static void purgePoolManager();
    //生命内存回收池类为友元类
    friend class CCAutoreleasePool;
};
其对应的实现： 

static CCPoolManager* s_pPoolManager = NULL;

CCAutoreleasePool::CCAutoreleasePool(void)
{
	//在堆中创建一个用于存放对象的容器
    m_pManagedObjectArray = new CCArray();
    //初始化这个容器
    m_pManagedObjectArray->init();
}

CCAutoreleasePool::~CCAutoreleasePool(void)
{
	//当该内存回收池被销毁时同时释放掉存放回收池的栈
    CC_SAFE_DELETE(m_pManagedObjectArray);
}

void CCAutoreleasePool::addObject(CCObject* pObject)
{
	//把指定对象加入到栈中
    m_pManagedObjectArray->addObject(pObject);
    //引用计数至少大于1
    CCAssert(pObject->m_uReference > 1, "reference count should be greater than 1");
    //指明该对象是受回收池管理（因为CCAutoreleasePool是CCObject的友元类，所以可以直接访问CCObject类的保护属性）
    ++(pObject->m_uAutoReleaseCount);
    //引用计数减1。（这里之所以要减1是因为在执行m_pManagedObjectArray->addObject(pObject)时pObject的引用计数也会加1，所以这里一定要调用release，将
    //引用计数减1，这样才能保持pObject对象的引用计数与原始的一样）
    pObject->release(); // no ref count, in this case autorelease pool added.
}

void CCAutoreleasePool::removeObject(CCObject* pObject)
{
	//从内存回收池中移除该对象（这里之所以有个循环是因为当一个对象加入到内存回收池时m_uAutoReleaseCount会加1，再加一次时m_uAutoReleaseCount也会再次加1，所以这里要加个循环，保证对象的引用计数得以正确次数减1）
    for (unsigned int i = 0; i < pObject->m_uAutoReleaseCount; ++i)
    {
        m_pManagedObjectArray->removeObject(pObject, false);
    }
}

void CCAutoreleasePool::clear()
{
    if(m_pManagedObjectArray->count() > 0)//如果内存回收池中有对象
    {
        //CCAutoreleasePool* pReleasePool;
#ifdef _DEBUG
        int nIndex = m_pManagedObjectArray->count() - 1;
#endif

        CCObject* pObj = NULL;
        CCARRAY_FOREACH_REVERSE(m_pManagedObjectArray, pObj)//遍历内存回收池中的对象
        {
            if(!pObj)//存在空对象，跳出
                break;

            --(pObj->m_uAutoReleaseCount);//被回收池管理的次数减1
            //(*it)->release();
            //delete (*it);
#ifdef _DEBUG
            nIndex--;
#endif
        }
        //移除所有回收池中的对象
        m_pManagedObjectArray->removeAllObjects();
    }
}


//--------------------------------------------------------------------
//
// CCPoolManager
//
//--------------------------------------------------------------------

CCPoolManager* CCPoolManager::sharedPoolManager()
{
	//创建一个内存回收池的管理对象的单例
    if (s_pPoolManager == NULL)
    {
        s_pPoolManager = new CCPoolManager();
    }
    return s_pPoolManager;
}

void CCPoolManager::purgePoolManager()
{
	//释放内存回收池的管理对象所指向的内存资源
    CC_SAFE_DELETE(s_pPoolManager);
}

CCPoolManager::CCPoolManager()
{
	//创建一个用于存放回收池的容器
    m_pReleasePoolStack = new CCArray();    
    m_pReleasePoolStack->init();
    //初始化内存回收池
    m_pCurReleasePool = 0;
}

CCPoolManager::~CCPoolManager()
{
    //清空所管理的回收池中的所有对象
    finalize();
 
    // we only release the last autorelease pool here 
    //防止野指针
    m_pCurReleasePool = 0;
    //删除第一个回收池对象（既然可以有多个内存回收池存在，为什么不用removeAllObjects，或者又因为在每帧调用的时候可以保证管理器中始终保持只有一个回收池？？？）
    m_pReleasePoolStack->removeObjectAtIndex(0);
    //释放存放回收池的容器的资源
    CC_SAFE_DELETE(m_pReleasePoolStack);
}

void CCPoolManager::finalize()
{
    if(m_pReleasePoolStack->count() > 0)//回收池栈中存在回收池
    {
        //CCAutoreleasePool* pReleasePool;
        CCObject* pObj = NULL;
        CCARRAY_FOREACH(m_pReleasePoolStack, pObj)
        {
            if(!pObj)//存在空对象，跳出
                break;
            CCAutoreleasePool* pPool = (CCAutoreleasePool*)pObj;
            pPool->clear();//清空当前的回收池中的所有对象
        }
    }
}

void CCPoolManager::push()
{
	//创建一个内存回收池
    CCAutoreleasePool* pPool = new CCAutoreleasePool();       //ref = 1
    //把刚创建出来的回收池的地址赋给m_pCurReleasePool
    m_pCurReleasePool = pPool;
    //回收池入栈
    m_pReleasePoolStack->addObject(pPool);                   //ref = 2
    //抵消刚才调用addObject(pPool)时的引用计数加1
    pPool->release();                                       //ref = 1
}

void CCPoolManager::pop()
{
    if (! m_pCurReleasePool)//当前的内存回收池为空，则返回
    {
        return;
    }
    //获取当前管理器中回收池的个数
    int nCount = m_pReleasePoolStack->count();
    //清空当前的回收池的所有对象
    m_pCurReleasePool->clear();
 
      if(nCount > 1)//回收池个数大于1
      {
        m_pReleasePoolStack->removeObjectAtIndex(nCount-1);//移除最后一个回收池，模拟出栈操作

//         if(nCount > 1)
//         {
//             m_pCurReleasePool = m_pReleasePoolStack->objectAtIndex(nCount - 2);
//             return;
//         }
        m_pCurReleasePool = (CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount - 2);//指定当前的回收池为出栈后的最后一个回收池
    }

    /*m_pCurReleasePool = NULL;*/
}

void CCPoolManager::removeObject(CCObject* pObject)
{
	//断言当前的回收池不能为空
    CCAssert(m_pCurReleasePool, "current auto release pool should not be null");
    //从当前的回收池中移除该对象
    m_pCurReleasePool->removeObject(pObject);
}

void CCPoolManager::addObject(CCObject* pObject)
{
	//将对象到内存回收池中
    getCurReleasePool()->addObject(pObject);
}

有了以上的了解后便可以用几个例子来熟悉cocos2d-x的内存管理大概是怎样的。


定义三个测试类，然后在AppDelegate中启动TestScene

class TestScene : public CCLayer
{
public:
    virtual bool init();  
    static cocos2d::CCScene* scene();
    CREATE_FUNC(TestScene);
};
class TestLayer : public CCLayer {
public:
	TestLayer() {
		CCLog("TestLayer()");
	};
	~TestLayer() {
		CCLog("~TestLayer()");
	};
	CREATE_FUNC(TestLayer);
	virtual bool init() {
		CCLog("TestLayer init");
		return true;
	};
};
class TestSp : public CCNode {
public:
	TestSp() {
		CCLog("TestSprite()");
	};
	~TestSp() {
		CCLog("~TestSprite()");
	};
	CREATE_FUNC(TestSp);
	virtual bool init() {
		CCLog("TestSprite init");
		return true;
	};
};

在第一个例子中，可以看到cocos2d-x是可以自动释放掉无用的对象

CCScene* TestScene::scene()
{
    CCScene * scene = NULL;
    do 
    {
        scene = CCScene::create();
        CC_BREAK_IF(! scene);
        TestScene *layer = TestScene::create();
        CC_BREAK_IF(! layer);
        scene->addChild(layer);
    } while (0);
    return scene;
}

bool TestScene::init()
{
    bool bRet = false;
    do 
    {
		//创建一个测试对象
		TestLayer* testLayer = TestLayer::create();
		//执行下面的代码后便表示testLayer已被当前的场景所管理，不会自动释放，通俗的讲游戏的执行需要它，所以才把它add到场景中，受当前对象管理
		this->addChild(testLayer);
		//创建一个测试对象
		TestSp* testSprite = TestSp::create();
		//创建完testSprite测试对象后下面的代码并没有引用它，所以它被cocos2d-x引擎看做是无用的对象，是需要进行回收的

        bRet = true;
    } while (0);

    return bRet;
}
打印的结果如下：

TestLayer()
TestLayer init
TestSprite()
TestSprite init
~TestSprite()

可以看到无用对象testSprite的析构函数确实被调用了。


接下来便分析这个调用过程和逻辑。

当testLayer和testSprite调用create时都调用了autorelease方法，其导致的结果是会把这两个对象都加到当前的一个内存回收池中。

CCObject* CCObject::autorelease(void)
{
	//加入到自动回收池中
    CCPoolManager::sharedPoolManager()->addObject(this);
    return this;
}
void CCPoolManager::addObject(CCObject* pObject)
{
	//将对象到内存回收池中
    getCurReleasePool()->addObject(pObject);
}
在加入到回收池的时候会引起变量m_uAutoReleaseCount的变化，当大于0时说明它是受回收池管理的 
void CCAutoreleasePool::addObject(CCObject* pObject)
{
	//把指定对象加入到栈中
    m_pManagedObjectArray->addObject(pObject);
    //引用计数至少大于1
    CCAssert(pObject->m_uReference > 1, "reference count should be greater than 1");
    //指明该对象是受回收池管理（因为CCAutoreleasePool是CCObject的友元类，所以可以直接访问CCObject类的保护属性）
    ++(pObject->m_uAutoReleaseCount);
    //引用计数减1。（这里之所以要减1是因为在执行m_pManagedObjectArray->addObject(pObject)时pObject的引用计数也会加1，所以这里一定要调用release，将
    //引用计数减1，这样才能保持pObject对象的引用计数与原始的一样）
    pObject->release(); // no ref count, in this case autorelease pool added.
}
这个时候testLayer和testSprite的引用计数的变化为：

1）构造对象的时候时候由于都是CCObject的子类的所以引用计数都为1

2）当调用了autorelease后会加入到内存回收池中，这时引用计数会加1，然后又被release了减1，所以最后的引用计数还是1。

3）因为testLayer又被addChild到场景中，所以引用计数又加1，即testLayer的引用计数为2，而testSprite的引用计数为1。

4）前面的文章提过在主循环中，主要处理两件事，一个场景的渲染，另一个就是内存的管理，也就是说，cocos2d-x游戏中，每一帧都会处理一次内存管理。

void CCDisplayLinkDirector::mainLoop(void)
{
    if (m_bPurgeDirecotorInNextLoop)
    {
        m_bPurgeDirecotorInNextLoop = false;
        purgeDirector();
    }
    else if (! m_bInvalid)
     {
         drawScene();
     
         // release the objects
         //释放内存
         CCPoolManager::sharedPoolManager()->pop();        
     }
}
可以看到管理的内存是调用时CCPoolManager::pop。 

void CCPoolManager::pop()
{
    if (! m_pCurReleasePool)//当前的内存回收池为空，则返回
    {
        return;
    }
    //获取当前管理器中回收池的个数
    int nCount = m_pReleasePoolStack->count();
    //清空当前的回收池的所有对象
    m_pCurReleasePool->clear();
 
      if(nCount > 1)//回收池个数大于1
      {
        m_pReleasePoolStack->removeObjectAtIndex(nCount-1);//移除最后一个回收池，模拟出栈操作

//         if(nCount > 1)
//         {
//             m_pCurReleasePool = m_pReleasePoolStack->objectAtIndex(nCount - 2);
//             return;
//         }
        m_pCurReleasePool = (CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount - 2);//指定当前的回收池为出栈后的最后一个回收池
    }

    /*m_pCurReleasePool = NULL;*/
}
可以看到这时当前的内存回收池会清空掉其所有的对象。 

void CCAutoreleasePool::clear()
{
    if(m_pManagedObjectArray->count() > 0)//如果内存回收池中有对象
    {
        //CCAutoreleasePool* pReleasePool;
#ifdef _DEBUG
        int nIndex = m_pManagedObjectArray->count() - 1;
#endif

        CCObject* pObj = NULL;
        CCARRAY_FOREACH_REVERSE(m_pManagedObjectArray, pObj)//遍历内存回收池中的对象
        {
            if(!pObj)//存在空对象，跳出
                break;

            --(pObj->m_uAutoReleaseCount);//被回收池管理的次数减1
            //(*it)->release();
            //delete (*it);
#ifdef _DEBUG
            nIndex--;
#endif
        }
        //移除所有回收池中的对象
        m_pManagedObjectArray->removeAllObjects();
    }
}
执行完这个操作后，当前的内存回收池会移除其所有对象（removeAllObjects会使引用计数减1）。所以这时testLayer的引用计数为1，而testSprite的引用计数为0。 

void CCArray::removeAllObjects()
{
    ccArrayRemoveAllObjects(data);
}
void ccArrayRemoveAllObjects(ccArray *arr)
{
	while( arr->num > 0 )
    {
		(arr->arr[--arr->num])->release();
    }
}
5）当调用release时会检测引用计数是否为0 
void CCObject::release(void)
{
    CCAssert(m_uReference > 0, "reference count should greater than 0");
    //引用计数减1
    --m_uReference;

    if (m_uReference == 0)//如果引用计数为0，则删除该对象
    {
        delete this;
    }
}
所以由于testSprite的引用计数为0，从而调用了testSprite的析构函数，而testLayer的引用计数为1，所以没有调用testLayer的析构函数

6）执行完以上操作由于之前管理的testSprite和testLayer的回收池出栈，导致存活下来的testLayer是不受内存回收池管理的，这时它的m_uAutoReleaseCount是为0的（这个变量的作用是在CCObject的析构函数中

CCObject::~CCObject(void)
{
    // if the object is managed, we should remove it
    // from pool manager
    if (m_uAutoReleaseCount > 0)//如果当该对象被销毁时，仍存在于内存回收池中，那么内存回收池清掉该对象
    {
        CCPoolManager::sharedPoolManager()->removeObject(this);
    }

    // if the object is referenced by Lua engine, remove it
    //下面与脚本引擎相关，略过
    if (m_nLuaID)
    {
        CCScriptEngineManager::sharedManager()->getScriptEngine()->removeScriptObjectByCCObject(this);
    }
    else
    {
        CCScriptEngineProtocol* pEngine = CCScriptEngineManager::sharedManager()->getScriptEngine();
        if (pEngine != NULL && pEngine->getScriptType() == kScriptTypeJavascript)
        {
            pEngine->removeScriptObjectByCCObject(this);
        }
    }
}
这样便能保证该对象如果被手动delete掉，且是受内存回收池管理的，那么内存回收池也会将其清掉）。

7）最后testLayer的资源便全权由场景来释放。所以总结出来的一句话是谁管理，谁负责释放（最后testLayer是由它的父类管理，所以父类有责任决定什么时候去释放它）。


[cocos2dx]重要父类——CCObject对象类
超越
04-26 2770
CCObject CCObject.h： #ifndef __CCOBJECT_H__ #define __CCOBJECT_H__ #include "platform/CCPlatformMacros.h" //Cocos2d命名空间 NS_CC_BEGIN //声明以下几种类，在后面会定义相应类的成员变量的指针。以下几个类均是CCObject类的派生类。 class CCZone
Cocos2d-x基础：CCObject
梦想的实践
08-12 2128
前几天在一家公司面试，当时被面到CCNode、CCObject、CCScene、CCACtion等是干什么用的，有什么意义。 由于我只大致看过一些资料，看了些Test工程而已，这些源码当时觉得暂时没必要看，实际的开发中会慢慢接触到。可现在知道我做错了，如果在使用一个技术之前，不好好的了解技术的原理，就是非常坑爹的事情！ 废话完了，希望和同学们一起好好分析这个类，达到举一反三，甚
【玩转cocos2d-x之二十】从CCObject看cocos2d-x的内存管理机制
偶尔e网事
10-31 6720
再看CCObject，剔除上节的拷贝相关，以及Lua脚本相关的属性和方法后，CCObject还剩下什么？ 1.剩下什么？ 可以看到整个CCObject就是围绕着m_uReference和m_uAutoReleaseCount在转。这两个变量的解释如下。所以CCObject剩下的其实就是对内存的管理。 CCObject::CCObject(void)//构造函数 : m_nLuaI
cocos2dx进阶学习之CCObject
weixin_30608503的博客
01-18 140
继承关系CCObject -> CCCopying类定义class CC_DLL CCObject : public CCCopying { public: // object id, CCScriptSupport need public m_uID unsigned int m_uID; // Lua reference id int ...
cocos2d-x节点（CCObject.h)API
runaying的专栏
12-06 1558
本文来自http://blog.youkuaiyun.com/runaying ，引用必须注明出处！ cocos2d-x节点（CCObject.h)API 温馨提醒：为了大家能更好学习，强烈推荐大家看看本人的这篇博客 Cocos2d-X权威指南笔记 对象引用计数器的使用和比较 ///\cocos2d-x-3.0alpha0\cocos2dx\cocoa //对象引用计数器的使用
Cocos2d-x的内存管理总结
09-04
Cocos2d-x内存管理的基础是引用计数，这一概念体现在基类CCObject中。每个CCObject实例都有两个关键的计数器：m_uReference表示引用计数，m_uAutoReleaseCount表示自动释放计数。当一个对象创建时，m_uReference默认...
Cocos2d-x内存管理详解：引用计数基础
Cocos2d-x内存管理的优化和最佳实践包括： - **使用智能指针**：如std::unique_ptr或Cocos2d-x的Ref等，它们能自动管理对象的生命周期，减少手动内存管理的复杂性。 - **理解C++的RAII（Resource Acquisition Is ...
Cocos2d-x内存管理深度解析：引用计数与自动释放
在Cocos2d-x中，内存管理是通过引用计数机制来实现的，这主要体现在CCObject类中，它是所有Cocos2d-x对象的基类。引用计数包括常规引用计数（m_uReference）和自动释放计数（m_uAutoReleaseCount）。当一个对象被...
cocos2d-x对象管理：引用计数与自动释放
`CCObject`类及其内存管理方法在cocos2d-x中扮演着至关重要的角色，确保了对象生命周期的正确控制，防止了内存泄漏和过早的释放。程序员应熟悉这些方法，以保证代码的健壮性和性能。在编写cocos2d-x应用时，合理使用...
cocos2d-x 源码分析 ： Ref （CCObject） 源码分析 cocos2d-x内存管理策略
poplaryang的点点滴滴
06-21 2469
1.Ref，AutorealsePool，PoolManager是紧密相关的 2.Ref的retain、new 应该与 release或者autoRealse成对出现。 3.Node的使用方式。
CCObject
weixin_33875564的博客
01-04 119
所有类的基类 所有的selector： 所有的selector typedef void (CCObject::*SEL_SCHEDULE)(float); typedef void (CCObject::*SEL_CallFunc)(); typedef void (CCObject::*SEL_CallFuncN)(CCNode*); typedef void (CCObjec...
cocos2.0中的CCObject与cocos3.0中的Ref的比较
l1008610的专栏
12-07 796
最近在学习Cocos的知识，将
CCObject类
游戏乐园，happy 工作，happy生活
01-25 842
class CC_DLL CCCopying { public: virtual CCObject* copyWithZone(CCZone* pZone); }; class CC_DLL CCObject : public CCCopying { public: // object id, CCScriptSupport need public m_uID unsig
CCObject.h
single51的专栏
11-15 829
#ifndef __CCOBJECT_H__ #define __CCOBJECT_H__ #include "platform/CCPlatformMacros.h" NS_CC_BEGIN /**  * @addtogroup base_nodes  * @{  */ class CCZone; class CCObject; class C
CCObject的分析：release、retain 基于2.2.3，增加3.2 ref对比，Director游戏主线分析
镜子蓝玉的专栏
10-06 1768
CCObject、ref、Director、Autorelease、PoolManager、scene渲染树 cocos2dx两个版本内存管理分析，实现程序员的版本迭代。 所以每次执行完clear，Manager中除了渲染树和_referenceCount>1都会被清理掉；可是pool被清理之后_referenceCount>=1的内存就如渲染树般泄露了，这个时候就需要我用自己release（delete）了。为什么会出现这样子的情况呢，实际上源于早前兼容ObjectC的代码继承过来的管理机制，可能之后Po
Cocos2d-x 的CCObject与autorelease 之深入分析
移动开发记录
11-08 174
[Cocos2d-x相关教程来源于红孩儿的游戏编程之路优快云博客地址：http://blog.youkuaiyun.com/honghaier] 红孩儿Cocos2d-X学习园地：249941957 [暂满]加群写：Cocos2d-x 红孩儿Cocos2d-X学习园地QQ2群：44208467加群写：Cocos2d-x 本章为我的Cocos2d-x教程一书初稿。望各位看官多提建议！ ...
【玩转cocos2d-x之十九】从CCObject看cocos2d-x的拷贝机制
偶尔e网事
10-30 7865
CCObject在之前的文章中出现了N次，它扮演了一个老祖宗的角色，但是它到底是做什么的？先从它看看cocos2d-x的拷贝机制吧。 1.CCCopying CCObject从CCCopying继承而来，而CCCopying拥有唯一的虚函数copyWithZone，这个函数可以认为是拷贝的一个协议，所有继承了CCObject并且需要实现拷贝功能的子类都可以通过它来实现，它的源码很简单，
cocos2d-x 4.0 学习之路（四）简单学习HelloWorld代码
03-09 4726
我们就从最开始的HelloWorld代码开始学习吧。 那么HelloWorld窗口是怎么显示出来的呢？我们得找到入口程序，当然是Main函数了。下面是HelloWorld的工程目录： 打开main.cpp，里面就2行代码，实际上的入口是Classes\AppDelegate.cpp AppDelegate.cpp 里面有一个applicationDidFinishLaunching()方法，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值