दिलचस्प पोस्ट
TypeError: अविनाशी प्रकार: 'dict' जीआरपी इतनी तेजी से कैसे चला जाता है? JQuery में एक ड्रॉपडाउन के मूल्य प्राप्त करें NavigateUpFromSameTask का उपयोग करते हुए एक गतिविधि से लौट रहा है () उदास और उदास एक सूची में निरंतर संख्या के समूह को पहचानें कीप्रेस पढ़ने के लिए पायथन विधि? रूट के मुताबिक डायरेक्टिव टेम्पलेटउपलेट बताएं डेटाफ्रेम के विभाजन को परिभाषित करने के लिए कैसे? MySQL स्ट्रिंग की जगह ओएस में क्या होता है जब हम सी में एक नल सूचक को dereference? रिमोट रिपॉज़िटरी में परिवर्तनों को धक्का करते समय यह Git चेतावनी संदेश क्या है? PHP से कैसे आप .bat फ़ाइल चला सकते हैं? गतिविधि खत्म करने के लिए मैं एनीमेशन कैसे जोड़ सकता / सकती हूं? जावा या सी # में एकाधिक वंशानुक्रम की अनुमति क्यों नहीं है?

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

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

Solutions Collecting From Web of "स्मार्ट पॉइंटर क्या है और मुझे कब उपयोग करना चाहिए?"

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

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

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

// 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 या boost::scoped_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! 

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


अद्यतन करें

यह उत्तर ज़्यादा पुराना है, और इसलिए वर्णन करता है कि उस समय 'अच्छा' क्या था, जो बूस्ट पुस्तकालय द्वारा प्रदान किए गए स्मार्ट पॉइंटर्स थे। सी std::unique_ptr बाद से, मानक पुस्तकालय ने पर्याप्त स्मार्ट पॉइंटर्स प्रकार उपलब्ध कराए हैं, और इसलिए आपको 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. 

आधुनिक सी ++ के इन दिनों के लिए यहां एक सरल जवाब दिया गया है:

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

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

छोटे परिचय पृष्ठ पर उपलब्ध है स्मार्ट संकेतक – क्या, क्यों, कौन सा? ।

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

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

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

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

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

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

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

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

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

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

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

यह भी देखें:

  • कचरा संग्रहण
  • डेटा स्वामित्व से संबंधित यह स्टैक ओवरफ़्लो प्रश्न

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

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

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

एक स्मार्ट पॉइंटर एक ऐसा ऑब्जेक्ट होता है जो एक पॉइंटर की तरह कार्य करता है, लेकिन इसके अतिरिक्त निर्माण, विनाश, प्रतिलिपि बनाना, हिलाना और डिफरेंसिंग पर नियंत्रण प्रदान करता है।

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

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

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

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

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

यहां समान उत्तर के लिए लिंक है: 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

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

चलो टी इस ट्यूटोरियल में क्लास होंगे सी + + में कंटेंट को 3 प्रकारों में विभाजित किया जा सकता है:

1) कच्चे संकेत :

 T a; T * _ptr = &a; 

स्मृति में एक स्थान के लिए वे मेमोरी एड्रेस रखते हैं सावधानी के साथ प्रयोग करें, क्योंकि कार्यक्रमों को ट्रैक रखने के लिए जटिल हो जाते हैं।

कॉन्स्ट डेटा या पते वाला संकेतक {पीछे से पढ़ें}

 T a ; const T * ptr1 = &a ; T const * ptr1 = &a ; 

एक डेटा टाइप करने के लिए सूचक जो एक const है जिसका अर्थ है कि आप पॉइंटर का उपयोग करके डेटा प्रकार को बदल नहीं सकते। यानी *ptr1 = 19 ; काम नहीं करेगा। लेकिन आप सूचक को स्थानांतरित कर सकते हैं यानी ptr1++ , ptr1-- ; आदि काम करेंगे पीछे की ओर पढ़ें: सूचक टाइप करने के लिए सूचक जो const है

  T * const ptr2 ; 

एक डेटा प्रकार टी के लिए एक कॉन्स्ट पॉइंटर जिसका अर्थ है कि आप पॉइंटर को नहीं ले जा सकते हैं, लेकिन आप पॉइंटर द्वारा इंगित किए गए मान को बदल सकते हैं। यानी *ptr2 = 19 काम करेगा लेकिन ptr2++ ; ptr2-- ptr2++ ; ptr2-- आदि काम नहीं करेगा पीछे की ओर पढ़ें: const पॉइंटर को एक प्रकार T में

 const T * const ptr3 ; 

एक const डेटा प्रकार टी के लिए एक const सूचक जिसका मतलब है आप या तो पॉइंटर को स्थानांतरित नहीं कर सकते हैं और न ही आप पॉइंटर होने के लिए डेटा टाइप पॉइंटर को बदल सकते हैं। अर्थात । ptr3-- ; ptr3++ ; *ptr3 = 19; काम नहीं करेगा

3) स्मार्ट पॉइंटर्स : { #include <memory> }

साझा पॉइंटर :

  T a ; //shared_ptr<T> shptr(new T) ; not recommended but works shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe std::cout << shptr.use_count() ; // 1 // gives the number of " things " pointing to it. T * temp = shptr.get(); // gives a pointer to object // shared_pointer used like a regular pointer to call member functions shptr->memFn(); (*shptr).memFn(); // shptr.reset() ; // frees the object pointed to be the ptr shptr = nullptr ; // frees the object shptr = make_shared<T>() ; // frees the original object and points to new object 

पॉइंटर द्वारा इंगित किए गए ऑब्जेक्ट को कितनी "चीजें" बिंदु का ट्रैक रखने के लिए संदर्भ गणना का उपयोग करके कार्यान्वित किया गया जब यह गिनती 0 पर जाती है, तो ऑब्जेक्ट को स्वचालित रूप से हटा दिया जाता है, यानी ऑब्जेक्ट हटा दिया जाता है, जब ऑब्जेक्ट की ओर इशारा करते हुए सभी share_ptr दायरे से बाहर हो जाता है। यह उन चीजों को हटाने के लिए सिरदर्द से छुटकारा दिलाता है, जिन्हें आपने नए प्रयोग से आवंटित किया है।

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

 T a ; shared_ptr<T> shr = make_shared<T>() ; weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr wk.lock()->memFn() ; // use lock to get a shared_ptr // ^^^ Can lead to exception if the shared ptr has gone out of scope if(!wk.expired()) wk.lock()->memFn() ; // Check if shared ptr has gone out of scope before access 

देखें: जब std :: weak_ptr उपयोगी है?

अद्वितीय पॉइंटर: अनन्य स्वामित्व के साथ हल्के वजन स्मार्ट पॉइंटर। पॉइंटर्स के बीच ऑब्जेक्ट साझा किए बिना पॉइंटर अद्वितीय ऑब्जेक्ट को इंगित करते समय उपयोग करें।

 unique_ptr<T> uptr(new T); uptr->memFn(); //T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr uptr.reset() ; // deletes the object pointed to by uptr 

अद्वितीय पीटीआर द्वारा इंगित वस्तु को बदलने के लिए, स्थानांतरित करें शब्दों का प्रयोग करें

 unique_ptr<T> uptr1(new T); unique_ptr<T> uptr2(new T); uptr2 = std::move(uptr1); // object pointed by uptr2 is deleted and // object pointed by uptr1 is pointed to by uptr2 // uptr1 becomes null 

सन्दर्भ: वे अनिवार्य रूप से const पॉइंटर्स के रूप में हो सकते हैं, अर्थात् एक सूचक जो कि const है और बेहतर सिंटैक्स से स्थानांतरित नहीं किया जा सकता।

देखें: सूचक चर और सी ++ में एक संदर्भ चर के बीच अंतर क्या हैं?

 r-value reference : reference to a temporary object l-value reference : reference to an object whose address can be obtained const reference : reference to a data type which is const and cannot be modified 

संदर्भ: https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ इस प्रश्न को इंगित करने के लिए आंद्रे के लिए धन्यवाद।

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

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

स्मार्ट पॉइंटर्स वे हैं जहां आपको मेमोरी डी-ऑलोकेशन, रिसोर्स शेयरिंग और ट्रांसफर के बारे में चिंता नहीं है

आप इन संकेतकों को बहुत अच्छी तरह से इसी तरह इस्तेमाल कर सकते हैं क्योंकि जावा में कोई आवंटन काम करता है। जावा कचरा कलेक्टर में यह चाल है, जबकि स्मार्ट पॉइंटर्स में, चाल डिस्ट्रक्टर्स द्वारा किया जाता है।