c++ - Is it safe to use a weak_ptr in a std::set or key of std::map -

std :: weak_ptr और std: के बारे में आज कई प्रश्न हुए हैं : owner_less और साहचर्य कंटेनरों std :: set और std :: map में उनका उपयोग करें। इसमें कई पद हैं जो एक weak_ptr का उपयोग करके एक std :: set में गलत है, क्योंकि अगर कमजोर संकेतक की समय सीमा समाप्त हो जाती है, तो यह अनिर्धारित व्यवहार होगा। क्या यह सही है?

एक कारण std :: owner_less मौजूद है इस आदेश को प्रदान करने के लिए, और कमजोर संकेतक समाप्त होने की उपस्थिति में इसकी सुरक्षा की गारंटी। मेरा तर्क है

सबसे पहले, std :: owner_less

• ऑपरेटर () की परिभाषा एक सख्त कमजोर आदेश को परिभाषित करता है जैसा कि 25.4

  में परिभाषित तुल्यता संबंध के तहत ऑपरेटर () , ! ऑपरेटर () (ए, बी) & amp; amp; ! ऑपरेटर () (बी, ए) , दो shared_ptr या कमजोर_पीटी उदाहरण समतुल्य हैं यदि और अगर वे स्वामित्व साझा करते हैं या दोनों खाली हैं।

  दो मामलों हैं

  1. वे एक ही वस्तु साझा करते हैं, जो व्यावहारिक दृष्टि से मतलब है कि वे एक ही संदर्भ गणना वस्तु साझा करते हैं। / Li>
  2. ये दोनों खाली हैं।

     अब, मुझे विश्वास है कि भ्रम की स्थिति दूसरी अवधि से अधिक है। कुंजी यह है कि मानक में "खाली" का मतलब है कि weak_ptr स्वामित्व को किसी वस्तु के साथ साझा नहीं करता है फिर से, मानक राज्य

     • constexpr कमजोर_पीटर () बिना सीधा;

       प्रभाव: एक खाली कमजोर_पीटर बनाता है ऑब्जेक्ट।
पोस्टकंडिशन: use_count () == 0 ।

     • कमजोर_पीटीआर (कॉन्स्ट कमजोर_प्रट्र & amp; आर) नोएसेसेप्ट;
     • टेम्पलेट & lt; वर्ग Y & gt; कमजोर_पीटआर (कॉन्स्ट कमजोर_प्रट्र & lt; Y & gt; & amp; आर) नोएसेसेप्ट;

     • टेम्पलेट & lt; वर्ग Y & gt; कमांडएपीटीआर (कॉन्स्ट शेअर्ड आईपीटी & lt; Y & gt; & amp; आर) बिना सीमा;

       आवश्यक है: दूसरे और तीसरे कन्स्ट्रक्टर ओवरलोड रिज़ॉल्यूशन में भाग नहीं लेंगे, जब तक कि Y * निहित न हो T * के लिए परिवर्तनीय

       प्रभाव: यदि r खाली है, तो खाली कमजोर_पीटर ऑब्जेक्ट का निर्माण करता है; अन्यथा, weak_ptr ऑब्जेक्ट का निर्माण करता है जो r के साथ स्वामित्व साझा करता है और r में संग्रहीत संकेतक की प्रतिलिपि रखता है।

       पोस्टकंडिशन: use_count () == r.use_count () ।

       स्वैप को दो के राज्यों को गमागमन के रूप में परिभाषित किया गया है < Code> weak_ptr s, और असाइनमेंट को एक स्वैप के साथ ऊपर के कंस्ट्रक्टरों के उपयोग के रूप में परिभाषित किया गया है।

       यहां ध्यान देने की कुंजी यह है कि खाली weak_ptr बनाने का एकमात्र तरीका यह तयशुदा रूप से निर्मित होता है, या पहले रिक्त weak_ptr से एक को प्रतिलिपि / स्थानांतरित / असाइन करता है या shared_ptr । यह भी नोट करना महत्वपूर्ण है कि आपको बस कमजोर_पीटर समाप्त होने से खाली weak_ptr नहीं मिल सकता है एक समय सीमा समाप्त weak_ptr में बस एक use_count शून्य है

       एक व्यावहारिक मामले के रूप में, जब कोई shared_ptr बनाया जाता है, तो एक संदर्भ गणना ऑब्जेक्ट बनाया जाना चाहिए, या तो shared_ptr कंस्ट्रक्टर का उपयोग करके डेटा से अलग होनी चाहिए , या एक ही स्मृति आवंटन में जब std :: make_shared उपयोग किया जाता है जब एक कमजोर_प्रतिक उस shared_ptr से बना है, तो वह उसी नियंत्रण संरचना और संदर्भ संख्या को इंगित करेगा। जब shared_ptr को नष्ट कर दिया जाता है, तो यह डेटा को नष्ट कर सकता है, लेकिन संदर्भ गणना ऑब्जेक्ट को सभी weak_ptr तक साझा करना होगा, ताकि शेयर स्वामित्व हटा दिए जाएं। अन्यथा, कमजोर_पीटीआर में एक लटकती संकेतक संदर्भ होगा।

       इस प्रकार, यह सब एक साथ उठाए जाने का मतलब है कि std :: weak_ptr जब तक कि आप std :: map या std :: set में की कुंजी, जब तक आप std :: owner_less का उपयोग करते हैं आदेश। उपरोक्त गारंटी देता है कि weak_ptr के आदेश समान रहेगा भले ही यह कंटेनर में होने पर समाप्त हो जाए