Cocos2d-x: मेमोरी लीक से बचने के लिए कुछ सुझाव

Cocos2d-x एक "इंजन" है, या बल्कि, कक्षाओं का एक सेट है जो ऑपरेटिंग सिस्टम जैसे कि iOS, Android, विंडोज फोन, विंडोज, साथ ही HTML के लिए ग्राफिकल अनुप्रयोगों के विकास को बहुत सरल करता है। HTML 5. cocos2d-iphone के विपरीत, cocos2d- x में C ++ विकास शामिल है, इसलिए यह इतना सार्वभौमिक है। C ++ में लिखने वालों को पता है कि मेमोरी को आवंटित करने और मुक्त करने की सारी जिम्मेदारी प्रोग्रामर के पास होती है। लेकिन cocos2d-x डेवलपर्स ने इसका अच्छे से ख्याल रखा और अपने अद्भुत इंजन में एक ऑब्जेक्ट पूल का निर्माण किया, जिसमें स्मार्ट पॉइंटर्स का उपयोग होता है या, दूसरे शब्दों में, स्मार्ट पॉइंटर्स। स्मार्ट पॉइंटर में अपने क्लाइंट का काउंटर होता है, जब काउंटर शून्य होता है, तो ऑब्जेक्ट के लिए आवंटित मेमोरी क्लियर हो जाती है। इस लेख में, मैं दिखाऊंगा कि मेमोरी लीक से बचने के लिए cocos2d-x में ऑब्जेक्ट्स को सही तरीके से कैसे बनाएं और डिलीट करें। सभी cocos2d-x क्लास ऑब्जेक्ट स्मार्ट पॉइंटर्स हैं। उन्हें यह कार्यक्षमता उनके माता-पिता CCObject से प्राप्त हुई, जो इंजन के क्लास लाइब्रेरी के पदानुक्रम में शुरुआती लिंक है।

आमतौर पर एक प्रोग्रामर जो ढेर में एक ऑब्जेक्ट बनाना चाहता है, निम्नलिखित कोड लिखता है:

CMyObject* pObject = new CMyObject(); // ,   CMyObject —    . 

इस स्थिति में, CMyObject को मेमोरी में बनाया जाता है और इसके पॉइंटर को pObject वैरिएबल में रखा जाता है। PObject की अब आवश्यकता नहीं होने के बाद, आपको मेमोरी वापस करने की आवश्यकता है:

 delete pObject; 

आमतौर पर, कई ऑब्जेक्ट्स काम कर रहे प्रोजेक्ट्स में बनाए जाते हैं, अक्सर एक एप्लिकेशन मॉड्यूल में नहीं होते हैं, और आपको यह सुनिश्चित करने की आवश्यकता होती है कि अंत में वे सभी हटा दिए जाते हैं, अन्यथा हमें मेमोरी लीक मिलती है। इस तरह के उपद्रव से बचने के लिए, cocos2d-x वस्तुओं को बनाने के लिए खुले स्थिर कार्यों का उपयोग करता है। खासकर जब प्रोग्रामर इंजन कक्षाओं की कार्यक्षमता का विस्तार करता है, तो उसे मेमोरी लीक से बचने के लिए इस नियम का पालन करना चाहिए।
Cocos2d-x में स्प्राइट बनाने के उदाहरण पर विचार करें:

 ... CCSprite* pSprite = CCSprite::create(«spritename.png»); ... 

बनाएँ - एक स्थिर कार्य - एक वस्तु बनाने के लिए CCSprite वर्ग का एक सदस्य। इस फ़ंक्शन के लिए कोड पर एक नज़र डालें:

 CCSprite* CCSprite::create(const char *pszFileName) { CCSprite *pobSprite = new CCSprite(); if (pobSprite && pobSprite->initWithFile(pszFileName)) { pobSprite->autorelease(); return pobSprite; } CC_SAFE_DELETE(pobSprite); return NULL; } 

सबसे पहले, हम एक ऑब्जेक्ट बनाते हैं, इसे कोड की मदद से आरंभ करते हैं:

 pobSprite->autorelease(); 

पूल में जोड़ें। यदि आरंभीकरण सफल रहा, तो हम CCSprite के लिए एक पॉइंटर लौटाएंगे, और यदि नहीं, तो CC_SAFE_DELETE pobSprite को हटा देगा।
इस फ़ंक्शन को निष्पादित करने के बाद, हमारे pSprite में m_uReference एक के बराबर है और यह तब तक जीवित रहता है जब तक कि यह स्थानीय फ़ंक्शन से बाहर नहीं निकलता है, क्योंकि इंजन के प्रत्येक घड़ी चक्र पर पूल को अपडेट किया जाता है। आपको यहां सावधान रहना होगा: यदि क्लास के पुनर्वितरण में pSprite वैश्विक है, तो यह कचरा को इंगित करेगा। इसे रोकने के लिए, हमें बनाई गई वस्तु का उपयोग करने की आवश्यकता है। उदाहरण के लिए, परत में स्प्राइट जोड़ें:

 pLayer->addChild(pSprite); 

, या एक सरणी के लिए

 pArray->addObject(pSprite); 

और इसी तरह। हर बार pSprite जोड़ा जाता है, इसके m_uReference में वृद्धि होगी, जरूरी नहीं कि 1. यह इंजन का विशिष्ट कार्यान्वयन है, जिसके अंदर इसके कार्यकर्त्ता, arrays, आदि भी m_uReference को प्रभावित करते हैं। और हर बार pSprite को हटा दिया जाता है, उसके m_uReference तदनुसार घट जाएगा। आप विधियों का उपयोग करके अपने आप को m_uReference बढ़ा या घटा सकते हैं:

 pSprite->retain(); // m_uReference +=1 pStrite->release(); // m_uReference -=1 

इन विधियों का सावधानी से उपयोग करें, प्रत्येक अनुरक्षण () जारी करने के लिए कॉल के अनुरूप होना चाहिए ()। अन्यथा, ऑब्जेक्ट मेमोरी में रहेगा और मेमोरी लीक हो जाएगी।
अब बात करते हैं वर्गों के विस्तार की। मान लें कि हमें एक ऐसी वस्तु की आवश्यकता है जो लगभग CCSprite की तरह है, लेकिन अतिरिक्त कार्यक्षमता के साथ, बोनस कहें।
यहाँ मेरी परियोजना से एक व्युत्पन्न वर्ग घोषित करने का एक उदाहरण है:

 class TABonus:public CCSprite { TABonusType mType; TABonus(b2World* world, float pX, float pY,TABonusType type); virtual bool init(); public: float pBegX, pBegY; virtual ~TABonus(); static TABonus* create(b2World* world, float pX, float pY,TABonusType type); inline TABonusType getType() {return mType;} void update(float pSecondElapsed); }; 

ध्यान दें कि कंस्ट्रक्टर को बंद खंड में घोषित किया गया है - इसका मतलब है कि ऑब्जेक्ट का प्रत्यक्ष निर्माण निषिद्ध है। ऐसा करने के लिए, क्लास में एक स्थिर फ़ंक्शन क्रिएट घोषित किया जाता है।
आइए फ़ंक्शन कोड देखें:

 TABonus* TABonus::create(b2World* world, float pX, float pY,TABonusType type) { TABonus* pRet = new TABonus(world,pX,pY,type); if (pRet->init()) { pRet->autorelease(); return pRet; } CC_SAFE_DELETE(pRet); return NULL; } 

यह पहले के समान माना जाता है। अब, ताबोनस बनाने के लिए, आपको निम्नलिखित कोड का उपयोग करने की आवश्यकता है:

 TABonus* pBonus = TABonus::create(world,pX,pY, btCoins);// pBonus ->m_uReference == 0 pLayer->addChild(pBonus); //pBonus->m_uReference>0 

निष्कर्ष:

- नए ऑपरेटर के माध्यम से सीधे ऑब्जेक्ट बनाने से बचने की कोशिश करें, इसके लिए स्थैतिक कार्यों का उपयोग करें। इसके अलावा, एक व्युत्पन्न वर्ग से विरासत में मिलने पर, आपको अपने स्थिर कार्यों को लिखना होगा।
- किसी ऑब्जेक्ट को हटाने के लिए, आपको इसे उन सभी कंटेनरों से निकालने की आवश्यकता है जहां इसे जोड़ा गया था, फिर m_uReference को शून्य पर रीसेट किया जाएगा और ऑब्जेक्ट के लिए आवंटित मेमोरी को ढेर में वापस कर दिया जाएगा। उदाहरण के लिए, परत से pSprite को हटा दें:

 pLayer->removeChild(pSprite, true); 

या एक सरणी से:

 pArray->removeObject(pSprite); 

- स्थैतिक फ़ंक्शन में बनाई गई ऑब्जेक्ट के लिए डिलीट का उपयोग न करें, क्योंकि आपके अलावा कोई भी नहीं जानता है कि ऑब्जेक्ट अब नहीं है।
- वस्तु के रहने के लिए, आपको इसके m_uReference को कंटेनर में जोड़कर, या रिटेन () कहकर बढ़ाना होगा।

नियमों से खेलें और जीतें।

आपका ध्यान देने के लिए धन्यवाद।