मौजूदा मूल्यों को स्मार्ट-पीटीआरएस में असाइन करना?

मैं बस स्मार्ट पॉइंटर्स के बारे में सीख रहा हूं, और मुझे मानक लाइब्रेरी के साझा पॉइंटर में एक चर के पूर्व-मौजूदा स्थान को असाइन करने में समस्या हो रही है।

उदाहरण के लिए, मान लें कि आपके पास एक int x है, जिसे आप मान नहीं जानते हैं। सामान्य पॉइंटर्स के साथ, मैंने अभी किया

int* ptr;
ptr = &x;

मैंने साझा पॉइंटर्स के साथ दोनों की कोशिश की, और

std::tr1::shared_ptr ptr;
ptr = std::make_shared (&x)

इसलिए मैं इसे कैसे करना है इसके बारे में काफी हद तक खो गया हूं।

0
यह बेहद असंभव है कि आप एक चर के पते को एक साझा सूचक को पास करना चाहते हैं। साझा पॉइंटर्स का बिंदु यह है कि वे गतिशील रूप से आवंटित ऑब्जेक्ट प्रबंधित करते हैं।
जोड़ा लेखक john, स्रोत

4 उत्तर

साझा पॉइंटर्स का उपयोग गतिशील रूप से आवंटित स्मृति को प्रबंधित करने के लिए किया जाता है और अधिक सटीक रूप से, वे इस स्मृति के लिए स्वामित्व प्रबंधित करते हैं।

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

यह मूल रूप से गारंटी देता है कि जब कोई गतिशील रूप से आवंटित स्मृति पर इंगित करता है, तो यह स्मृति उपलब्ध होगी, और जैसे ही इस स्मृति में अंतिम (स्मार्ट) पॉइंटर्स गुंजाइश से बाहर हो जाएंगे, फिर delete </कोड> कहा जाता है।

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

0
जोड़ा

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

0
जोड़ा

आप (आमतौर पर) एक मौजूदा चर के लिए एक स्मार्ट सूचक बिंदु नहीं करेंगे। एक स्मार्ट सूचक एक गतिशील रूप से आवंटित वस्तु के जीवनकाल का प्रबंधन करता है, इसे उपयोग के बाद हटा देता है; इसे किसी ऐसे चीज पर इंगित करना जो गतिशील रूप से आवंटित नहीं किया गया था, अगर यह इसे हटाने का प्रयास करता है तो त्रुटि उत्पन्न होगी।

ऑब्जेक्ट बनाने के लिए आप आमतौर पर new या make_shared का उपयोग करेंगे, और इसके परिणामस्वरूप स्मार्ट पॉइंटर बनाएं या असाइन करें:

std::shared_ptr ptr(new int(42));//Create a new pointer to manage an object
ptr.reset(new int(66));               //Reset to manage a different object
ptr = std::make_shared(53);      //Use `make_shared` rather than `new`

make_shared is usually preferable to new, since it makes better use of memory and gives stronger exception-safety.

0
जोड़ा

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

डिलीटर एक साधारण फ़ंक्शन (सामान्य ऑपरेटर डिलीट पर डिफ़ॉल्ट) है जो स्मार्ट पॉइंटर से बाध्य होना चाहिए, या तो स्थिर रूप से टेम्पलेट पैरामीटर के माध्यम से (देखें unique_ptr ) या गतिशील रूप से कन्स्ट्रक्टर पैरामीटर के माध्यम से (देखें shared_ptr )।

// dynamically via shared_ptr:
//   shared_ptrs share the pointer to the Deleter
//   because they already share a common data structure for reference counting.
auto ignore = [](int* o){
    std::cout<<"i will refuse to delete this object: " << o << "\n";
    std::cout<<"not my responsibility." < sptr(&x,ignore);


//statically via unique_ptr:
//  actually, the unique_ptr is as data structure not more than a regular pointer.
//  but a pointer with special copy-constructor and destructor,
//  which will most likely be inlined.
//  there is no space to store a reference to a Deleter dynamically.
struct IgnorantDeleter{
    void operator()(int* o){
        std::cout<<"who ate my cake? " << o << "\n";
        std::cout<<"but i baked it." < uptr(&x);
0
जोड़ा