उदाहरण के लिए:क्या यह एक एसएलएल कंटेनर असाइन करना सुरक्षित है?
set<int> s1;
set<int> s2;
s1.insert(1);
s2.insert(2);
s1 = s2;
यह सुरक्षित है? यदि हां, तो पुराना तत्व कहां था (और वे स्मृति क्या हुई)?
उदाहरण के लिए:क्या यह एक एसएलएल कंटेनर असाइन करना सुरक्षित है?
set<int> s1;
set<int> s2;
s1.insert(1);
s2.insert(2);
s1 = s2;
यह सुरक्षित है? यदि हां, तो पुराना तत्व कहां था (और वे स्मृति क्या हुई)?
हाँ आपके उदाहरण सुरक्षित हैं। लेकिन ध्यान दें: आप s2 को s2 असाइन नहीं करते हैं, आप s2 को s1 पर कॉपी करते हैं। अधिक जानकारी के लिए यह देखें: set::operator=
हां। पुराने तत्व सामान्य तरीके से नष्ट हो जाएंगे और किसी भी स्मृति को मुक्त कर दिया जाएगा। (सामान्य रूप से यदि आप कंटेनर में पॉइंटर्स स्टोर करते हैं तो यह केवल पॉइंटर को नष्ट कर देगा, और यह उस चीज़ को मुक्त नहीं करेगा जो इसे इंगित करता है)
अफैइक यह वास्तव में गलत है। 's1 = s2' केवल s2 में तत्व को कॉपी करता है और उन्हें s1 में रखता है। एक बार ब्लॉक के अंत तक पहुंचने के बाद दोनों वस्तुएं नष्ट हो जाती हैं। –
@ लुकासस्चेलजेसेन, उस सेट के पुराने तत्व जिन्हें आप प्रतिलिपि बना रहे हैं। – chris
स्पष्ट होने के लिए मेरा मतलब है कि एस 1 में पुराने तत्व "नष्ट हो जाएंगे" और कंटेनर द्वारा उपयोग की जाने वाली किसी भी स्मृति को एस 2 के दौरान मुक्त कर दिया जाएगा। ब्लॉक के अंत में ऑब्जेक्ट्स एस 1 और एस 2 निश्चित रूप से हटा दिए जाएंगे। – jcoder
हां यह असाइनमेंट करना सुरक्षित है। यह कॉपी कन्स्ट्रक्टर या असाइनमेंट ऑपरेटर को कॉल करता है और पुराने तत्व s1
में मिटा दिए जाते हैं और s2
के तत्वों द्वारा प्रतिस्थापित किए जाते हैं।
[ध्यान दें:। किसी भी संभावित समस्या हो गया होता तो कॉपी निर्माता और असाइनमेंट fstream
, ofstream
, ifstream
तरह मना किया गया है |]
काम सुरक्षित है।
असाइनमेंट ऑपरेटर मूल रूप से एस 1 में निहित वस्तुओं को नष्ट कर देगा (उनके उदाहरण में int के लिए एक छोटा नो-ऑप)। चाहे सेट स्मृति को भी मुक्त करता है, या इसे बाद में जोड़े गए तत्वों द्वारा उपयोग के लिए अनियमित स्मृति के रूप में बनाए रखता है, कार्यान्वयन तक है।
एस 1 में नई वस्तुओं को एस 2 में से कॉपी किया जाएगा, जो काफी समय ले सकता है। यदि आप असाइनमेंट के बाद एस 2 को रखना नहीं चाहते हैं, तो बेहतर कंटेनर दो कंटेनरों को स्वैप करना या सी ++ 11 चाल असाइनमेंट का उपयोग करना हो सकता है।
std::swap(s1, s2); // Backwards-compatible swap
s1 = std::move(s2); // C++11 rvalue move assignment
इनमें से
दोनों सबसे अधिक संभावना सिर्फ एक सूचक स्वैप जाएगा, सामग्री आप एस 1 में रखना चाहते हैं और s2 में बाकी है, छोड़ने जब s2 दायरे से बाहर चला जाता है, हटाए जाने की।
कक्षाओं और ऑपरेटर ओवरलोडिंग का उपयोग करने के बारे में यह अच्छी बात है। उपयोगकर्ता को इसके बारे में चिंता करने के बिना आप उस सामान का ख्याल रख सकते हैं। – chris