अपडेट करें
यह उत्तर पुराना है, और इसलिए वर्णन करता है कि उस समय क्या 'अच्छा' था, जो बूस्ट लाइब्रेरी द्वारा प्रदान किए गए स्मार्ट पॉइंटर्स थे। C ++ 11 के बाद से, मानक पुस्तकालय ने पर्याप्त स्मार्ट पॉइंटर्स प्रकार प्रदान किए हैं, और इसलिए आपको इसके उपयोग का पक्ष लेना चाहिए std::unique_ptr, std::shared_ptrऔर std::weak_ptr।
भी था std::auto_ptr। यह एक स्कोप्ड पॉइंटर की तरह बहुत अधिक था, सिवाय इसके कि इसमें "विशेष" खतरनाक नकल करने की क्षमता भी थी - जो अप्रत्याशित रूप से स्वामित्व को स्थानांतरित करता है।
इसे C ++ 11 में हटा दिया गया था और C ++ 17 में हटा दिया गया था , इसलिए आपको इसका उपयोग नहीं करना चाहिए।
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.
पुराने ANSWER
एक स्मार्ट पॉइंटर एक ऐसा वर्ग है जो इंगित किए गए ऑब्जेक्ट के जीवनकाल को प्रबंधित करने के लिए एक 'रॉ' (या 'नंगे') C ++ पॉइंटर को लपेटता है। एक भी स्मार्ट पॉइंटर प्रकार नहीं है, लेकिन ये सभी एक कच्चे पॉइंटर को एक व्यावहारिक तरीके से अमूर्त करने की कोशिश करते हैं।
कच्चे पॉइंटर्स पर स्मार्ट पॉइंटर्स को प्राथमिकता दी जानी चाहिए। यदि आपको लगता है कि आपको पॉइंटर्स का उपयोग करने की आवश्यकता है (पहले विचार करें कि क्या आप वास्तव में करते हैं), तो आप सामान्य रूप से एक स्मार्ट पॉइंटर का उपयोग करना चाहते हैं क्योंकि यह कच्चे पॉइंटर्स के साथ कई समस्याओं को दूर कर सकता है, मुख्य रूप से ऑब्जेक्ट को हटाने और मेमोरी को लीक करना भूल सकता है।
कच्चे पॉइंटर्स के साथ, प्रोग्रामर को ऑब्जेक्ट को स्पष्ट रूप से तबाह करना पड़ता है जब वह उपयोगी नहीं होता है।
// 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()
{
{
std::unique_ptr<MyObject> ptr(new MyObject());
ptr->DoSomethingUseful();
} // ptr goes out of scope --
// the MyObject is automatically destroyed.
// ptr->Oops(); // Compile error: "ptr" not defined
// since it is no longer in scope.
}
ध्यान दें कि std::unique_ptrउदाहरणों की प्रतिलिपि नहीं बनाई जा सकती है। यह पॉइंटर को कई बार (गलत तरीके से) डिलीट होने से बचाता है। हालाँकि, आप अपने द्वारा कॉल किए जाने वाले अन्य कार्यों के लिए इसका संदर्भ दे सकते हैं।
std::unique_ptrs तब उपयोगी होते हैं जब आप ऑब्जेक्ट के जीवनकाल को कोड के किसी विशेष ब्लॉक में बाँधना चाहते हैं, या यदि आप इसे किसी अन्य ऑब्जेक्ट के अंदर सदस्य डेटा के रूप में एम्बेड करते हैं, तो उस अन्य ऑब्जेक्ट का जीवनकाल। ऑब्जेक्ट तब तक मौजूद रहता है जब तक कि कोड के ब्लॉक से बाहर नहीं निकल जाता है, या जब तक कि संबंधित ऑब्जेक्ट स्वयं नष्ट नहीं हो जाता है।
अधिक जटिल स्मार्ट पॉइंटर नीति में पॉइंटर की गिनती के संदर्भ शामिल होते हैं। यह पॉइंटर को कॉपी करने की अनुमति देता है। जब ऑब्जेक्ट के लिए अंतिम "संदर्भ" नष्ट हो जाता है, तो ऑब्जेक्ट हटा दिया जाता है। इस नीति के द्वारा कार्यान्वित किया जाता है 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 {
std::shared_ptr<Owner> other;
};
std::shared_ptr<Owner> p1 (new Owner());
std::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!
इस समस्या के आसपास काम करने के लिए, बूस्ट और सी ++ 11 ने ए weak_ptrको कमजोर (बेशुमार) संदर्भ को परिभाषित करने के लिए परिभाषित किया है shared_ptr।