इसे दो रूपों की आवश्यकता क्यों है? धन्यवादसी ++ auto_ptr में दो प्रति रचनाकार और दो असाइनमेंट ऑपरेटर क्यों हैं लेकिन एक डिफ़ॉल्ट कन्स्ट्रक्टर?
explicit auto_ptr (T* ptr = 0) throw()
auto_ptr (auto_ptr& rhs) throw()
template<class Y>
auto_ptr (auto_ptr<Y>& rhs) throw()
auto_ptr& operator= (auto_ptr& rhs) throw()
template<class Y>
auto_ptr& operator= (auto_ptr<Y>& rhs) throw()
क्योंकि प्रतिलिपि बनाने वाले टेम्पलेट टेम्पलेट नहीं हो सकते हैं। अगर उनके पास केवल टेम्पलेट संस्करण था तो संकलक ऐसा करेगा जो सही ढंग से काम नहीं करेगा।
असाइनमेंट सेशन के लिए ही ... मुझे लगता है।
गैर-टेम्पलेट संस्करणों का कारण auto_ptr एस को असाइन/निर्माण के लिए उसी प्रकार के लिए अनुमति देना है। टेम्पलेट संस्करण मौजूदा से निर्माण/असाइनमेंट की अनुमति देने के लिए मौजूद हैं, लेकिन समान सूचक प्रकार नहीं हैं। गैर टेम्प्लेटेड एक -
auto_ptr <Foo> f = new Foo(); // uses raw pointer constructor
auto_ptr <Foo> f2 = f; // uses non-templated constructor
auto_ptr <const Foo> f3 = f2; // uses templated constructor
auto_ptr <Foo> f4 = new foo();
f2 = f4; // uses non-templated assignment operator
f3 = f2; // uses templated assignment operator
यह एक प्रतिलिपि निर्माता है। एक पूरी तरह से अलग रूप में संकलक व्यवहार करता है auto_ptr<A> के रूप में,
class A {}
class B : public A {}
B * b = new B();
A * a = b; // OK!
auto_ptr<B> b(new B);
auto_ptr<A> a = b; // *
, (*) से काम नहीं होगा:
टेम्पलेट निर्माता और असाइनमेंट ऑपरेटर सूचक प्रकार का काम है जिसके लिए एक अंतर्निहित मौजूद है की अनुमति देते हैं auto_ptr<B> से टाइप करें।
नहीं, एक स्थैतिक कलाकार (जो उदाहरण के लिए ए * से बी * रूपांतरण की अनुमति देगा) का उपयोग नहीं किया जाता है। लागू रूपांतरण का उपयोग किया जाता है। –
मेरा बुरा, फ्रेड, और इसे ठीक किया। – peterchen
सी ++ auto_ptr में दो प्रति रचनाकार और दो असाइनमेंट ऑपरेटर क्यों हैं लेकिन एक डिफ़ॉल्ट कन्स्ट्रक्टर?
ऐसा नहीं है।
यह 1 डिफ़ॉल्ट निर्माता (एक निर्माता कि 0 तर्क लेता है)
explicit auto_ptr (T* ptr = 0) throw()
है यह है 1 प्रतिलिपि निर्माता (एक निर्माता है कि एक ही प्रकार के एक वस्तु से एक प्रतिलिपि बनाता है)
auto_ptr (auto_ptr& rhs) throw()
इसमें 1 असाइनमेंट ऑपरेटर है जिसका उपयोग उसी प्रकार की ऑब्जेक्ट्स को असाइन करने के लिए किया जाता है।
auto_ptr& operator= (auto_ptr& rhs) throw()
यह एक फैंसी टेम्प्लेट की निर्माता है कि अन्य प्रकार के auto_ptr लेता है (यह एक प्रति निर्माता यह किसी सामान्य निर्माता है (हालांकि यह टेम्प्लेटेड है नहीं है))।
template<class Y>
auto_ptr (auto_ptr<Y>& rhs) throw()
यह एक और असाइनमेंट ऑपरेटर कि ऑटो सूचक के विभिन्न प्रकार लेता है (तो हाँ यह एक और असाइनमेंट ऑपरेटर है, लेकिन यह एक प्रति असाइनमेंट ऑपरेटर (लेकिन एक रूपांतरण असाइनमेंट ऑपरेटर) आरएचएस के रूप में एक अलग प्रकार का है नहीं है) ।
template<class Y>
auto_ptr& operator= (auto_ptr<Y>& rhs) throw()
विरासत टेम्पलेट का उपयोग करने का एक बेहतर उदाहरण बनाता है, लेकिन यह सीवी मतभेदों पर भी लागू होता है। –
@ फ्रेड, हां, विरासत अधिक आम मामला है, लेकिन कम संक्षिप्त उदाहरण के लिए बनाता है। – Eclipse
ऐसा लगता है कि एफ 4 घोषणा रेखा में दो चीजें खो गईं, क्या आपका मतलब auto_ptr f4 = new foo() है? –