निर्धारक कचरा कलेक्टर सूचक से मिलें

मेमोरी, सी ++ में इसके साथ काम करना हमेशा मुश्किल था ( सी की कड़वी विरासत) ... यहां सी ++ 11 अपने एसटीडी के साथ :: साझा किया गया। हमारी सहायता के लिए आता है।


जैसा कि आपने अनुमान लगाया होगा, अगर इन आदिमियों को कोई समस्या नहीं थी, तो यह लेख नहीं होगा :)

आइए std पर एक क्लासिक मेमोरी लीक के निम्नलिखित उदाहरण को देखें: share_ptr :

#include <iostream> #include <memory> class Child; class Parent { public: Parent() { std::cout << "Parent()" << std::endl; } ~Parent() { std::cout << "~Parent()" << std::endl; } void createChild() { child_ptr_ = std::make_shared<Child>(); } std::shared_ptr<Child> getChild() { return child_ptr_; } private: std::shared_ptr<Child> child_ptr_; }; class Child { public: Child() { std::cout << "Child()" << std::endl; } ~Child() { std::cout << "~Child()" << std::endl; } void setParent(std::shared_ptr<Parent> parentPtr) { parent_ptr_ = parentPtr; } private: std::shared_ptr<Parent> parent_ptr_; }; int main() { auto parent = std::make_shared<Parent>(); parent->createChild(); parent->getChild()->setParent(parent); return 0; } 

जाहिर है, हम ऑब्जेक्ट डिस्ट्रक्टर्स की कॉल नहीं देखेंगे। इससे कैसे निपटें? std :: weak_ptr हमारी सहायता के लिए आता है:

 ... class Child { ... void setParent(std::shared_ptr<Parent> parentPtr) { parent_ptr_ = parentPtr; } private: std::weak_ptr<Parent> parent_ptr_; }; ... 

हां, यह समस्या को हल करने में मदद करता है। लेकिन अगर आपके पास वस्तुओं का अधिक जटिल पदानुक्रम है और यह समझना बहुत मुश्किल है कि किसे करना चाहिए std :: weak_ptr और किसे std होना चाहिए :: share_ptr ? या क्या आप ढीले कनेक्शन के साथ बिल्कुल गड़बड़ नहीं करना चाहते हैं?

कचरा इकट्ठा करने वाला हमारा सब कुछ है !!

नहीं, बिल्कुल नहीं। C ++ में, गारबेज कलेक्टर के लिए कोई देशी समर्थन नहीं है, और अगर इसे जोड़ा जाता है, तो भी हमें गारबेज कलेक्टर के लिए ओवरहेड लागत मिलती है, साथ ही RAII टूट जाता है।

हम क्या करें?

निर्धारक गारबेज कलेक्टर पॉइंटर एक पॉइंटर है जो रूट ऑब्जेक्ट्स से सभी लिंक को ट्रैक करता है और जैसे ही रूट ऑब्जेक्ट्स में से कोई भी हमारी ऑब्जेक्ट को संदर्भित नहीं करता है, इसे तुरंत हटा दिया जाता है।

इसके संचालन का सिद्धांत std :: साझा_ptr (यह स्कोप को ट्रैक करता है ) के समान है, लेकिन यह भी ऑब्जेक्ट जो इसे संदर्भित करता है।

आइए पिछले उदाहरण में इसके संचालन के सिद्धांत को देखें:

 #include <iostream> #include "gc_ptr.hpp" class Child; class Parent { public: Parent() { std::cout << "Parent()" << std::endl; } ~Parent() { std::cout << "~Parent()" << std::endl; } void createChild() { child_ptr_.create_object(); } memory::gc_ptr<Child> getChild() { return child_ptr_; } void connectToRoot(void * rootPtr) { child_ptr_.connectToRoot(rootPtr); } void disconnectFromRoot(bool isRoot, void * rootPtr) { child_ptr_.disconnectFromRoot(isRoot, rootPtr); } private: memory::gc_ptr<Child> child_ptr_; }; class Child { public: Child() { std::cout << "Child()" << std::endl; } ~Child() { std::cout << "~Child()" << std::endl; } void setParent(memory::gc_ptr<Parent> parentPtr) { parent_ptr_ = parentPtr; } void connectToRoot(void * rootPtr) { parent_ptr_.connectToRoot(rootPtr); } void disconnectFromRoot(bool isRoot, void * rootPtr) { parent_ptr_.disconnectFromRoot(isRoot, rootPtr); } private: memory::gc_ptr<Parent> parent_ptr_; }; int main() { memory::gc_ptr<Parent> parent; parent.create_object(); parent->createChild(); parent->getChild()->setParent(parent); return 0; } 

जैसा कि आप देख सकते हैं, कोड थोड़ा और अधिक हो गया है, लेकिन यह वह मूल्य है जो आपको वस्तुओं को पूरी तरह से स्वचालित रूप से हटाने के लिए भुगतान करना होगा। यह देखा जा सकता है कि अतिरिक्त connectToRoot और disconnectFromRoot विधियों को जोड़ा गया है। बेशक, हर समय अपने हाथों से लिखना काफी मुश्किल होगा, इसलिए मैं इन तरीकों का एक छोटा जनरेटर उन कक्षाओं में बनाने का इरादा रखता हूं जो gc_ptr का उपयोग करते हैं (जैसा कि हम देखते हैं कि हम शून्य-ओवरहेड सिद्धांत का पालन करते हैं, हम भुगतान नहीं करते हैं कि हम क्या उपयोग नहीं करते हैं, और यदि हम उपयोग नहीं करते हैं- तब लागतें अधिक नहीं होती हैं यदि हम इसे अपने हाथों से लिखते हैं)।

Gc_ptr.hpp लाइब्रेरी थ्रेड-सुरक्षित है, यह कचरा संग्रहण के लिए कोई अतिरिक्त थ्रेड नहीं बनाता है, सब कुछ कंस्ट्रक्टर, डिस्ट्रक्टर और असाइनमेंट ऑपरेटरों में किया जाता है, इसलिए यदि हम अपनी वस्तु को ओवरराइट करते हैं और कोई रूट ऑब्जेक्ट अब इसे संदर्भित नहीं करता है, तो हम वापस आ जाते हैं। हमारी वस्तु के लिए आवंटित स्मृति।

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