c++ - एक स्मार्ट सूचक क्या है और मुझे कब उपयोग करना चाहिए?




pointers c++11 (10)

एक स्मार्ट सूचक क्या है और मुझे कब उपयोग करना चाहिए?

https://code.i-harness.com


अधिकांश प्रकार के स्मार्ट पॉइंटर्स आपके लिए ऑब्जेक्ट करने के लिए पॉइंटर का निपटान संभालते हैं। यह बहुत आसान है क्योंकि आपको ऑब्जेक्ट्स को मैन्युअल रूप से निपटाने के बारे में सोचना नहीं है।

सबसे अधिक उपयोग किए जाने वाले स्मार्ट पॉइंटर्स std::tr1::shared_ptr (या boost::shared_ptr ) हैं, और, कम सामान्यतः, std::auto_ptr । मैं shared_ptr नियमित उपयोग की सलाह देते हैं।

shared_ptr बहुत बहुमुखी है और निपटान परिदृश्यों की एक बड़ी विविधता से संबंधित है, जिसमें मामलों को "डीएलएल सीमाओं में पारित करने" की आवश्यकता होती है (सामान्य दुःस्वप्न मामला यदि आपके कोड और डीएलएल के बीच अलग-अलग libc का उपयोग किया जाता है)।


आधुनिक सी ++ के इन दिनों के लिए यहां एक सरल उत्तर दिया गया है:

  • एक स्मार्ट सूचक क्या है?
    यह एक प्रकार का मान है जिसे पॉइंटर की तरह इस्तेमाल किया जा सकता है, लेकिन स्वचालित मेमोरी प्रबंधन की अतिरिक्त सुविधा प्रदान करता है: जब पॉइंटर अब उपयोग में नहीं आता है, तो जिस स्मृति को इंगित किया जाता है उसे हटा दिया जाता है ( विकिपीडिया पर अधिक विस्तृत परिभाषा भी देखें)।
  • मुझे कब उपयोग करना चाहिए?
    कोड में जिसमें स्मृति के एक टुकड़े के स्वामित्व को ट्रैक करना, आवंटित करना या आवंटित करना शामिल है; स्मार्ट पॉइंटर अक्सर आपको इन चीजों को स्पष्ट रूप से करने की आवश्यकता बचाता है।
  • लेकिन उन मामलों में से किस स्मार्ट पॉइंटर का उपयोग करना चाहिए?
    • जब आप एक ही ऑब्जेक्ट पर एकाधिक संदर्भ रखने का इरादा नहीं रखते हैं तो std::unique_ptr उपयोग करें। उदाहरण के लिए, इसे पॉइंटर के लिए स्मृति के लिए उपयोग करें जो कुछ गुंजाइश दर्ज करने और दायरे से बाहर निकलने पर आवंटित करने पर आवंटित हो जाता है।
    • जब आप अपने ऑब्जेक्ट को एकाधिक स्थानों से संदर्भित करना चाहते हैं तो std::shared_ptr उपयोग करें - और यह नहीं चाहते कि इसे सभी आवंटित किए जाने तक इसे आवंटित न किया जाए।
    • जब आप अपने ऑब्जेक्ट को एकाधिक स्थानों से संदर्भित करना चाहते हैं तो std::weak_ptr उपयोग करें - उन संदर्भों के लिए जिनके लिए इसे अनदेखा करना और हटाना ठीक है (इसलिए वे केवल ध्यान दें कि जब आप अव्यवस्था का प्रयास करते हैं तो वस्तु समाप्त हो जाती है)।
    • boost:: स्मार्ट पॉइंटर्स या std::auto_ptr उपयोग न करें, विशेष मामलों को छोड़कर जिन्हें आप पढ़ सकते हैं।
  • अरे, मैंने नहीं पूछा कि किस का उपयोग करना है!
    आह, लेकिन आप वास्तव में चाहते थे, इसे स्वीकार करें।
  • तो मुझे नियमित पॉइंटर्स का उपयोग कब करना चाहिए?
    ज्यादातर कोड में जो स्मृति स्वामित्व के लिए अनजान है। यह आमतौर पर उन कार्यों में होगा जो किसी और जगह से पॉइंटर प्राप्त करते हैं और उनके निष्पादन को समाप्त करने वाले सूचक की एक प्रति आवंटित या आवंटित नहीं करते हैं।

एक स्मार्ट पॉइंटर एक ऐसी कक्षा है जो ऑब्जेक्ट के जीवनकाल को इंगित करने के लिए 'कच्चे' (या 'नंगे') सी ++ पॉइंटर को लपेटती है। कोई भी स्मार्ट पॉइंटर प्रकार नहीं है, लेकिन उनमें से सभी एक व्यावहारिक तरीके से कच्चे सूचक को अमूर्त करने का प्रयास करते हैं।

कच्चे पॉइंटर्स पर स्मार्ट पॉइंटर्स को प्राथमिकता दी जानी चाहिए। यदि आपको लगता है कि आपको पॉइंटर्स का उपयोग करने की आवश्यकता है (पहले विचार करें कि आप वास्तव में करते हैं), तो आप आमतौर पर एक स्मार्ट पॉइंटर का उपयोग करना चाहते हैं क्योंकि यह कच्चे पॉइंटर्स के साथ कई समस्याओं को कम कर सकता है, मुख्य रूप से ऑब्जेक्ट को हटाने और स्मृति को लीक करना भूल जाता है।

कच्चे पॉइंटर्स के साथ, प्रोग्रामर को ऑब्जेक्ट को स्पष्ट रूप से नष्ट करना होता है जब यह अब उपयोगी नहीं होता है।

// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?

तुलनात्मक रूप से एक स्मार्ट सूचक एक नीति को परिभाषित करता है जब ऑब्जेक्ट नष्ट हो जाता है। आपको अभी भी ऑब्जेक्ट बनाना है, लेकिन अब आपको इसे नष्ट करने की चिंता करने की ज़रूरत नहीं है।

SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception

उपयोग में सबसे सरल नीति में स्मार्ट पॉइंटर रैपर ऑब्जेक्ट का दायरा शामिल है, जैसे boost::scoped_ptr या std::unique_ptr द्वारा कार्यान्वित किया गया है।

void f()
{
    {
       boost::scoped_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // boost::scopted_ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}

ध्यान दें कि scoped_ptr उदाहरणों की प्रतिलिपि नहीं बनाई जा सकती है। यह सूचक को कई बार हटाए जाने से रोकता है (गलत तरीके से)। हालांकि, आप इसे कॉल करने वाले अन्य कार्यों के संदर्भ में संदर्भ भेज सकते हैं।

स्कोप्ड पॉइंटर्स उपयोगी होते हैं जब आप ऑब्जेक्ट के जीवनकाल को कोड के किसी विशेष ब्लॉक पर जोड़ना चाहते हैं, या यदि आपने किसी अन्य ऑब्जेक्ट के अंदर सदस्य डेटा के रूप में एम्बेड किया है, तो उस अन्य ऑब्जेक्ट का जीवनकाल। ऑब्जेक्ट मौजूद है जब तक कि कोड के युक्त ब्लॉक को बाहर नहीं किया जाता है, या जब तक कि ऑब्जेक्ट स्वयं नष्ट नहीं हो जाता है।

एक और जटिल स्मार्ट पॉइंटर नीति में पॉइंटर की गणना करने वाले संदर्भ शामिल हैं। यह सूचक की प्रतिलिपि बनाने की अनुमति देता है। जब ऑब्जेक्ट का अंतिम "संदर्भ" नष्ट हो जाता है, तो ऑब्जेक्ट हटा दिया जाता है। यह नीति boost::shared_ptr और std::shared_ptr द्वारा कार्यान्वित की जाती है।

void f()
{
    typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
    MyObjectPtr p1; // Empty

    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1 = p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.

संदर्भ गिनती पॉइंटर्स बहुत उपयोगी होते हैं जब आपकी ऑब्जेक्ट का जीवनकाल अधिक जटिल होता है, और सीधे कोड के किसी विशेष अनुभाग या किसी अन्य ऑब्जेक्ट से बंधे नहीं होते हैं।

संदर्भित पॉइंटर्स को संदर्भित करने में एक कमी है - एक खतरनाक संदर्भ बनाने की संभावना:

// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!

एक और संभावना परिपत्र संदर्भ बना रही है:

struct Owner {
   boost::shared_ptr<Owner> other;
};

boost::shared_ptr<Owner> p1 (new Owner());
boost::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!

इस समस्या को हल करने के लिए, बूस्ट और सी ++ दोनों ने एक weak_ptr को कमजोर (uncounted) संदर्भ परिभाषित करने के लिए एक weak_ptr परिभाषित किया है।

अद्यतन करें

यह उत्तर पुराना है, और इस समय वर्णन करता है कि उस समय 'अच्छा' क्या था, जो बूस्ट लाइब्रेरी द्वारा प्रदान किए गए स्मार्ट पॉइंटर्स थे। सी ++ 11 के बाद से, मानक पुस्तकालय ने पर्याप्त स्मार्ट पॉइंटर्स प्रकार प्रदान किए हैं, और इसलिए आपको std::unique_ptr , std::shared_ptr और std::weak_ptr के उपयोग का पक्ष लेना चाहिए।

std::auto_ptr भी है। यह एक स्कोप्ड पॉइंटर की तरह है, सिवाय इसके कि इसमें "विशेष" खतरनाक क्षमता भी कॉपी की जा सकती है - जो अनपेक्षित रूप से स्वामित्व स्थानांतरित करती है! यह नवीनतम मानकों में बहिष्कृत है, इसलिए आपको इसका उपयोग नहीं करना चाहिए। इसके बजाय std::unique_ptr उपयोग करें।

std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.

एक स्मार्ट पॉइंटर नियमित (टाइप किए गए) सूचक की तरह होता है, जैसे कि "char *", सिवाय इसके कि जब पॉइंटर स्वयं दायरे से बाहर हो जाता है तो यह भी क्या इंगित करता है। आप इसे "->" का उपयोग करके नियमित सूचक के रूप में उपयोग कर सकते हैं, लेकिन यदि आपको डेटा में वास्तविक सूचक की आवश्यकता नहीं है। इसके लिए, आप "& * ptr" का उपयोग कर सकते हैं।

यह इसके लिए उपयोगी है:

  • ऑब्जेक्ट्स जिन्हें नए के साथ आवंटित किया जाना चाहिए, लेकिन आप उस स्टैक पर कुछ वही जीवनकाल रखना चाहते हैं। यदि ऑब्जेक्ट को स्मार्ट पॉइंटर को असाइन किया गया है, तो प्रोग्राम उस फ़ंक्शन / ब्लॉक से बाहर निकलने पर हटा दिया जाएगा।

  • कक्षाओं के डेटा सदस्य, ताकि जब ऑब्जेक्ट हटा दिया जाता है तो सभी स्वामित्व वाले डेटा भी नष्ट हो जाते हैं, विनाशक में किसी भी विशेष कोड के बिना (आपको यह सुनिश्चित करने की आवश्यकता होगी कि विनाशक आभासी है, जो लगभग हमेशा एक अच्छी बात है) ।

आप एक स्मार्ट सूचक का उपयोग नहीं करना चाहेंगे जब:

  • ... सूचक को वास्तव में डेटा का स्वामित्व नहीं होना चाहिए ... यानी, जब आप केवल डेटा का उपयोग कर रहे हैं, लेकिन आप इसे उस समारोह में जीवित रखना चाहते हैं जहां आप इसे संदर्भित कर रहे हैं।
  • ... स्मार्ट पॉइंटर खुद को किसी बिंदु पर नष्ट नहीं किया जा रहा है। आप यह स्मृति में बैठना नहीं चाहते हैं जो कभी नष्ट नहीं हो जाता है (जैसे किसी ऑब्जेक्ट में जो गतिशील रूप से आवंटित होता है लेकिन स्पष्ट रूप से हटाया नहीं जाएगा)।
  • ... दो स्मार्ट पॉइंटर्स एक ही डेटा को इंगित कर सकते हैं। (हालांकि, यहां तक ​​कि स्मार्ट पॉइंटर्स भी हैं जो इसे संभाल लेंगे ... जिसे संदर्भ गिनती कहा जाता है।)

यह भी देखें:


एक स्मार्ट सूचक एक वस्तु है जो एक सूचक की तरह कार्य करता है, लेकिन इसके अतिरिक्त निर्माण, विनाश, प्रतिलिपि, चलती और dereferencing पर नियंत्रण प्रदान करता है।

कोई व्यक्ति अपने स्वयं के स्मार्ट पॉइंटर को कार्यान्वित कर सकता है, लेकिन कई पुस्तकालयों में विभिन्न फायदे और दोषों के साथ स्मार्ट पॉइंटर कार्यान्वयन भी प्रदान किया जाता है।

उदाहरण के लिए, Boost निम्नलिखित स्मार्ट सूचक कार्यान्वयन प्रदान करता है:

  • shared_ptr<T> ऑब्जेक्ट की आवश्यकता नहीं होने पर यह निर्धारित करने के लिए संदर्भ संख्या का उपयोग कर T लिए एक सूचक है।
  • scoped_ptr<T> एक पॉइंटर स्वचालित रूप से हटा दिया जाता है जब यह दायरे से बाहर हो जाता है। कोई असाइनमेंट संभव नहीं है।
  • intrusive_ptr<T> एक और संदर्भ गिनती सूचक है। यह shared_ptr से बेहतर प्रदर्शन प्रदान करता है, लेकिन टाइप T को अपनी संदर्भ गणना प्रणाली प्रदान करने की आवश्यकता होती है।
  • weak_ptr<T> एक कमजोर सूचक है, जो परिपत्र संदर्भों से बचने के लिए shared_ptr संयोजन के साथ काम करता है।
  • shared_array<T> की तरह है, लेकिन T सरणी के लिए है।
  • scoped_array<T> scoped_ptr की तरह है, लेकिन T सरणी के लिए है।

ये प्रत्येक के केवल एक रैखिक वर्णन हैं और आवश्यकता के अनुसार उपयोग किए जा सकते हैं, आगे विस्तार और उदाहरणों के लिए बूस्ट के दस्तावेज़ीकरण को देख सकते हैं।

इसके अतिरिक्त, सी ++ मानक पुस्तकालय तीन स्मार्ट पॉइंटर्स प्रदान करता है; अद्वितीय स्वामित्व के लिए std::unique_ptr , साझा स्वामित्व और std::weak_ptr लिए std::shared_ptrstd::auto_ptr C ++ 03 में मौजूद था लेकिन अब इसे बहिष्कृत किया गया है।


क्रिस, सर्गेदेव और लियोड द्वारा प्रदान की गई परिभाषाएं सही हैं। हालांकि, मैं अपने जीवन को सरल रखने के लिए एक सरल परिभाषा पसंद करता हूं: एक स्मार्ट सूचक बस एक वर्ग है जो -> और * ऑपरेटरों को अधिभारित करता है। जिसका अर्थ है कि आपका ऑब्जेक्ट अर्थात् एक सूचक की तरह दिखता है लेकिन आप संदर्भ गणना, स्वचालित विनाश इत्यादि सहित कूलर चीजों को कर सकते हैं। shared_ptr और auto_ptr ज्यादातर मामलों में पर्याप्त हैं, लेकिन छोटे idiosyncrasies के अपने सेट के साथ आते हैं।


मौजूदा उत्तर अच्छे हैं लेकिन जब कोई स्मार्ट पॉइंटर हल करने की कोशिश कर रहे समस्या का पूरा (पूर्ण) उत्तर नहीं है तो क्या करना है, इसे कवर न करें।

स्मार्ट पॉइंटर का उपयोग करके अन्य चीजों के अलावा (अन्य उत्तरों में अच्छी तरह से समझाया गया) एक संभावित समाधान है कि हम फ़ंक्शन रिटर्न प्रकार के रूप में एक अमूर्त वर्ग का उपयोग कैसे करते हैं? जिसे इस प्रश्न के डुप्लिकेट के रूप में चिह्नित किया गया है। हालांकि, यह पूछने वाला पहला सवाल है कि सी ++ में वापसी प्रकार के रूप में एक सार (या वास्तव में, किसी भी) बेस क्लास को निर्दिष्ट करने के लिए प्रेरित किया गया है, "आप वास्तव में क्या मतलब है?"। बूस्ट पॉइंटर कंटेनर लाइब्रेरी के दस्तावेज़ीकरण में सी ++ (और यह अन्य भाषाओं के लिए अलग कैसे है) में बेवकूफ ऑब्जेक्ट उन्मुख प्रोग्रामिंग की एक अच्छी चर्चा (आगे संदर्भों के साथ) है। संक्षेप में, सी ++ में आपको स्वामित्व के बारे में सोचना होगा। कौन सा स्मार्ट पॉइंटर्स आपकी मदद करता है, लेकिन एकमात्र समाधान नहीं है, या हमेशा एक पूर्ण समाधान नहीं है (वे आपको पॉलिमॉर्फिक प्रति नहीं देते हैं) और हमेशा एक समाधान नहीं है जिसे आप अपने इंटरफेस में बेनकाब करना चाहते हैं (और फ़ंक्शन रिटर्न एक भयानक लगता है एक इंटरफ़ेस की तरह बहुत)। उदाहरण के लिए, संदर्भ को वापस करने के लिए पर्याप्त हो सकता है। लेकिन इन सभी मामलों में (स्मार्ट पॉइंटर, पॉइंटर कंटेनर या बस एक संदर्भ लौट रहे हैं) आपने किसी मान से रिटर्न को संदर्भ के रूप में बदल दिया है। यदि आपको वास्तव में प्रतिलिपि की आवश्यकता है तो आपको अधिक बॉयलरप्लेट "मुहावरे" या एडोब पॉली या Boost.TypeErasure जैसे लाइब्रेरीज़ का उपयोग करके अधिक सामान्य पॉलीमोर्फिज्म के लिए सी ++ में Boost.TypeErasure (या अन्यथा) Boost.TypeErasureBoost.TypeErasure


यहां समान उत्तरों के लिए लिंक दिया गया है: http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

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

उदाहरण:

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

यह वर्ग टाइप एक्स के ऑब्जेक्ट में एक स्मार्ट पॉइंटर लागू करता है। ऑब्जेक्ट ही ढेर पर स्थित होता है। यहां इसका उपयोग कैसे करें:

smart_pointer <employee> p= employee("Harris",1333);

अन्य अधिभारित ऑपरेटरों की तरह, पी नियमित सूचक की तरह व्यवहार करेगा,

cout<<*p;
p->raise_salary(0.5);

http://en.wikipedia.org/wiki/Smart_pointer

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


स्मार्ट पॉइंटर एक पॉइंटर-जैसा प्रकार है जिसमें कुछ अतिरिक्त कार्यक्षमता है, उदाहरण के लिए स्वचालित मेमोरी डेलोकेशन, संदर्भ गिनती इत्यादि।

पृष्ठ स्मार्ट प्वाइंटर्स पर छोटा परिचय उपलब्ध है - क्या, क्यों, कौन?

सरल स्मार्ट-पॉइंटर प्रकार में से एक std::auto_ptr (सी ++ मानक का अध्याय 20.4.5) है, जो स्कोप से बाहर होने पर स्वचालित रूप से स्मृति को डिलीकेट करने की अनुमति देता है और अपवादों को फेंकने पर सरल सूचक उपयोग से अधिक मजबूत होता है, हालांकि कम लचीला।

एक और सुविधाजनक प्रकार boost::shared_ptr जो संदर्भ गिनती लागू करता है और जब ऑब्जेक्ट का कोई संदर्भ नहीं रहता है तो स्वचालित रूप से स्मृति को हटा देता है। यह स्मृति रिसाव से बचने में मदद करता है और RAII को लागू करने के लिए उपयोग करना आसान है।

विषय डेविड वंदेवोर्डे, निकोलाई एम जोसुटिस , अध्याय अध्याय 20. स्मार्ट प्वाइंटर्स द्वारा "सी ++ टेम्पलेट्स: द पूर्ण गाइड" पुस्तक में गहराई में शामिल है। कुछ विषय शामिल हैं:

  • अपवादों के खिलाफ सुरक्षा
  • धारकों, (नोट, std::auto_ptr ऐसे प्रकार के स्मार्ट सूचक का कार्यान्वयन है)
  • संसाधन अधिग्रहण प्रारंभ है (यह अक्सर सी ++ में अपवाद-सुरक्षित संसाधन प्रबंधन के लिए उपयोग किया जाता है)
  • धारक सीमाएं
  • संदर्भ गणना
  • समवर्ती काउंटर एक्सेस
  • विनाश और डीलोकेशन






c++-faq