शुरुआती के लिए स्मार्ट पॉइंटर्स

यह संक्षिप्त लेख मुख्य रूप से शुरुआती सी ++ प्रोग्रामर के लिए है, जो या तो स्मार्ट पॉइंटर्स के बारे में सुनते हैं, लेकिन उनका उपयोग करने से डरते थे, या वे नए-डिलीट का ट्रैक रखते हुए थक गए थे।

UPD: लेख तब लिखा गया था जब C ++ 11 अभी तक इतना लोकप्रिय नहीं था।

इसलिए, C ++ प्रोग्रामर जानते हैं कि मेमोरी को फ्रीज करने की आवश्यकता है। हमेशा वांछनीय। और वे जानते हैं कि यदि नया कहीं लिखा गया है, तो एक समान विलोपन होना चाहिए। लेकिन स्मृति के साथ मैनुअल जोड़तोड़ भयावह हो सकता है, उदाहरण के लिए, निम्न त्रुटियों के साथ:

• स्मृति लीक;
• एक अशक्त सूचक को डीफेरफ्रेंस करना या स्मृति के एक अनइंस्टाल्यूटेड क्षेत्र तक पहुंचना;
• पहले से हटाई गई वस्तु को हटाना

एक रिसाव, सिद्धांत रूप में, यदि प्रोग्राम 24/7 काम नहीं करता है, या कोड इसे कॉल नहीं करता है तो यह बहुत महत्वपूर्ण नहीं है। जब एक अशक्त सूचक को हटाते हुए, हमें एक सेगफॉल्ट प्राप्त करने की गारंटी दी जाती है, तो यह केवल मामले को खोजने के लिए रहता है जब यह शून्य हो जाता है (आप जानते हैं कि मेरा क्या मतलब है)। बार-बार हटाने के साथ, कुछ भी हो सकता है। आमतौर पर (हालांकि यह हमेशा नहीं हो सकता है), यदि मेमोरी का एक ब्लॉक आपको आवंटित किया गया है, तो इसके आगे कहीं एक मूल्य निहित है जो आवंटित मेमोरी की मात्रा निर्धारित करता है। विवरण कार्यान्वयन पर निर्भर हैं, लेकिन मान लें कि आपने कुछ पते पर शुरू होने वाली 1 kb मेमोरी आवंटित की है। फिर, 1024 नंबर को पिछले पते पर संग्रहीत किया जाएगा, इसलिए कॉल को हटाते समय मेमोरी के बिल्कुल 1024 बाइट को हटाना संभव होगा, इससे अधिक नहीं और कम नहीं। पहली बार जब आप हटाते हैं, तो सब कुछ ठीक होता है, दूसरा आप गलत डेटा मिटा देते हैं। इस सब से बचने के लिए, या इस तरह की त्रुटि की संभावना को कम करने के लिए, स्मार्ट पॉइंटर्स का आविष्कार किया गया था।

परिचय

RAII नामक स्थानीय वस्तुओं के माध्यम से एक संसाधन प्रबंधन तकनीक है। यही है, जब एक संसाधन प्राप्त होता है, तो इसे कंस्ट्रक्टर में आरंभीकृत किया जाता है, और एक फ़ंक्शन में इसके साथ काम करने के बाद, इसे विध्वंसक में सही ढंग से जारी किया जाता है। एक संसाधन कुछ भी हो सकता है, उदाहरण के लिए एक फ़ाइल, एक नेटवर्क कनेक्शन, और हमारे मामले में एक मेमोरी ब्लॉक। यहाँ एक सरल उदाहरण है:

class VideoBuffer { int *myPixels; public: VideoBuffer() { myPixels = new int[640 * 480]; } void makeFrame() { /*    */ } ~VideoBuffer() { delete [] myPixels; } }; int game() { VideoBuffer screen; screen.makeFrame(); } 

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

 int game() { int *myPixels = new int[640 * 480]; //  delete [] myPixels; } 

सिद्धांत रूप में, कोई अंतर नहीं है, लेकिन ऐसे कोड की कल्पना करें:

 int game() { int *myPixels = new int[640 * 480]; //  if (someCondition) return 1; //   if (someCondition) return 4; //  delete [] myPixels; } 

फ़ंक्शन निकास की प्रत्येक शाखा में डिलीट [] लिखना या किसी भी अतिरिक्त डी-इनिशियलाइज़ेशन फ़ंक्शन को कॉल करना आवश्यक है। और अगर बहुत सारे मेमोरी आवंटन हैं, या वे फ़ंक्शन के विभिन्न हिस्सों में होते हैं? इस सब पर नज़र रखना कठिन और कठिन होगा। एक समान स्थिति तब होती है जब हम फ़ंक्शन के बीच में एक अपवाद फेंकते हैं: यह गारंटी दी जाती है कि स्टैक पर ऑब्जेक्ट नष्ट हो जाएंगे, लेकिन समस्याओं का एक गुच्छा के साथ समस्या खुली रहती है।
ठीक है, हम RAII का उपयोग करेंगे, निर्माणकर्ताओं में मेमोरी को इनिशियलाइज़ करेंगे, इसे विध्वंसक में मुक्त करेंगे। और हमारी कक्षा के क्षेत्रों को गतिशील स्मृति के वर्गों की ओर संकेत करते हैं:

 class Foo { int *data1; double *data2; char *data3; public: Foo() { data1 = new int(5); ... } ~Foo() { delete data1; ... } } 

अब कल्पना करें कि फ़ील्ड 3 नहीं हैं, लेकिन 30 हैं, जिसका अर्थ है कि विध्वंसक में आपको उन सभी के लिए कॉल हटाना होगा। और अगर जल्दी में हम एक नया क्षेत्र जोड़ते हैं, लेकिन इसे विध्वंसक में मारना भूल जाते हैं, तो परिणाम नकारात्मक होंगे। परिणाम एक वर्ग है जो मेमोरी एलोकेशन / डीललोकेशन ऑपरेशंस से भरा हुआ है, और यह स्पष्ट नहीं है कि सब कुछ सही तरीके से हटा दिया गया था या नहीं।
इसलिए, स्मार्ट पॉइंटर्स का उपयोग करने का प्रस्ताव है: ये ऐसी वस्तुएं हैं जो पॉइंटर्स को एक मनमाने प्रकार की मेमोरी के डायनामिक रूप से आवंटित वर्गों में स्टोर करती हैं। इसके अलावा, वे गुंजाइश छोड़ने पर स्वचालित रूप से मेमोरी को साफ़ करते हैं।
पहले, आइए देखें कि वे C ++ में कैसे दिखते हैं, फिर कुछ सामान्य प्रकार के स्मार्ट पॉइंटर्स के अवलोकन पर जाएं।

सबसे सरल स्मार्ट पॉइंटर

 //     template <typename T> class smart_pointer { T *m_obj; public: //       smart_pointer(T *obj) : m_obj(obj) { } //          ~smart_pointer() { delete m_obj; } //  < // .      T  "" T* operator->() { return m_obj; } //             // ,    T& operator* () { return *m_obj; } } int test { //  myClass     smart_pointer<MyClass> pMyClass(new MyClass(/*params*/); //     MyClass   pMyClass->something(); // ,          ostream //          , //       std::cout << *pMyClass << std::endl; //      MyClass   } 

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

• बढ़ावा :: scoped_ptr
• std :: auto_ptr
• std :: tr1 :: shared_ptr (उर्फ std :: share_ptr C ++ 11 में, या बढ़ावा :: शेयर_ptr बूस्ट से)

बढ़ावा :: scoped_ptr

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

 #include <boost/scoped_ptr.hpp> int test() { boost::scoped_ptr<int> p1(new int(6)); boost::scoped_ptr<int> p2(new int(1)); p1 = p2; // ! } 

यह समझने योग्य है, यदि असाइनमेंट की अनुमति दी गई थी, तो p1 और P2 एक ही मेमोरी क्षेत्र को इंगित करेंगे। और फ़ंक्शन से बाहर निकलने पर, दोनों को हटा दिया जाएगा। क्या होगा? किसी को पता नहीं है। तदनुसार, इस सूचक को फ़ंक्शंस में स्थानांतरित नहीं किया जा सकता है।
फिर इसकी आवश्यकता क्यों है? मैं आपको किसी भी डेटा के लिए एक रैपर पॉइंटर के रूप में उपयोग करने की सलाह देता हूं जो फ़ंक्शन की शुरुआत में गतिशील रूप से आवंटित किया जाता है और संसाधनों की सही सफाई के बारे में सिरदर्द से खुद को बचाने के लिए अंत में हटा दिया जाता है।
विस्तृत विवरण यहाँ ।

std :: auto_ptr

पिछले एक का थोड़ा सुधार हुआ संस्करण, इसके अलावा, यह मानक पुस्तकालय में है (हालांकि C ++ 11 में यह पदावनत की तरह लगता है)। इसमें एक असाइनमेंट ऑपरेटर और एक कॉपी कंस्ट्रक्टर है, लेकिन वे कुछ असामान्य काम करते हैं।
मैं समझाता हूं:

 #include <memory> int test() { std::auto_ptr<MyObject> p1(new MyObject); std::auto_ptr<MyObject> p2; p2 = p1; } 

अब, जब P2 को असाइन किया जाता है, तो MyObject (जो हमने p1 के लिए बनाया है) का पॉइंटर होगा, और p1 में कुछ भी नहीं होगा। यही है, पी 1 अब शून्य पर रीसेट हो गया है। यह आंदोलन का तथाकथित शब्दार्थ है। वैसे, कॉपी ऑपरेटर ऐसा ही करता है।
इसकी आवश्यकता क्यों है? ठीक है, उदाहरण के लिए, आपके पास एक फ़ंक्शन है जो किसी प्रकार का ऑब्जेक्ट बनाना चाहिए:

 std::auto_ptr<MyObject> giveMeMyObject(); 

इसका मतलब यह है कि फ़ंक्शन MyObject प्रकार का एक नया ऑब्जेक्ट बनाता है और इसे आपके निपटान में डालता है। यह स्पष्ट हो जाएगा यदि यह फ़ंक्शन स्वयं एक वर्ग का सदस्य है (फैक्ट्री कहें): आपको यकीन है कि यह क्लास (फ़ैक्टरी) किसी अन्य पॉइंटर को एक नई वस्तु में संग्रहीत नहीं करता है। आपकी वस्तु और एक सूचक।
ऐसे असामान्य शब्दार्थों के कारण, Auto_ptr का उपयोग STL कंटेनरों में नहीं किया जा सकता है। लेकिन हमने share_ptr किया है।

std :: share_ptr (C ++ 11)

संदर्भ गिनती के साथ स्मार्ट पॉइंटर। इसका क्या मतलब है? इसका मतलब है कि कहीं न कहीं एक निश्चित चर है जो ऑब्जेक्ट को संदर्भित करने वाले पॉइंटर्स की संख्या को संग्रहीत करता है। यदि यह चर शून्य के बराबर हो जाता है, तो वस्तु नष्ट हो जाती है। काउंटर ऑपरेटर या असाइनमेंट ऑपरेटर को या तो प्रत्येक कॉल के साथ वेतन वृद्धि दी जाती है। Shared_ptr में एक बूल कास्ट ऑपरेटर भी है, जो अंततः हमें मेमोरी को खाली करने की चिंता किए बिना पॉइंटर्स का सामान्य सिंटैक्स देता है।

 #include <memory> //  <tr1/memory>  ,    C++11 #include <iostream> int test() { std::shared_ptr<MyObject> p1(new MyObject); std::shared_ptr<MyObject> p2; p2 = p1; if (p2) std::cout << "Hello, world!\n"; } 

अब P2 और p1 दोनों एक ही ऑब्जेक्ट को इंगित करते हैं, और संदर्भ काउंटर 2 है, स्कोप से बाहर निकलने पर, काउंटर रीसेट हो जाता है, और ऑब्जेक्ट नष्ट हो जाता है। हम इस पॉइंटर को एक फंक्शन में पास कर सकते हैं:

 int test(std::shared_ptr<MyObject> p1) { //  - } 

ध्यान दें कि यदि आप एक पॉइंटर को संदर्भ द्वारा पास करते हैं, तो काउंटर को इंक्रीमेंट नहीं किया जाएगा। आपको सुनिश्चित होना चाहिए कि परीक्षण फ़ंक्शन निष्पादित होने के दौरान MyObject जीवित रहेगा।

इसलिए स्मार्ट पॉइंटर्स अच्छे हैं, लेकिन डाउनसाइड्स हैं।
सबसे पहले, यह एक छोटा ओवरहेड है, लेकिन मुझे लगता है कि आपको इस तरह की सुविधा के लिए कई प्रोसेसर चक्र मिलेंगे।
उदाहरण के लिए दूसरा यह बॉयलर-प्लेट है

 std::tr1::shared_ptr<MyNamespace::Object> ptr = std::tr1::shared_ptr<MyNamespace::Object>(new MyNamespace::Object(param1, param2, param3)) 

उदाहरण के लिए, इसे परिभाषित करके आंशिक रूप से हल किया जा सकता है:

 #define sptr(T) std::tr1::shared_ptr<T> 

या टाइप्डिफ का उपयोग कर।
तीसरा , परिपत्र संदर्भों की समस्या है। मैं इसे यहां नहीं मानूंगा, ताकि लेख को बड़ा न कर सकूं। बूस्ट :: weak_ptr, बढ़ावा :: intrusive_ptr और सरणियों के लिए संकेत भी अपरिचित बने रहे।
वैसे, स्मार्ट पॉइंटर्स का वर्णन जेफ अल्जीरिया द्वारा "वास्तविक प्रोग्रामरों के लिए C ++" में किया गया है।