नीचे कोड स्निपेट सी ++ के लिए स्पष्टीकरण

मैं C ++ 11 Faq पढ़ रहा था और इस कोड में आया था। मुझे सी ++ कोडिंग की बेहतर समझ है, लेकिन मैं अभी भी नीचे दिए गए कोड को समझने में सक्षम नहीं हूं।

    template
    class Handle {
        T* p;
    public:
        Handle(T* pp) : p{pp} {}
        ~Handle() { delete p; }//user-defined destructor: no implicit copy or move 

        Handle(Handle&& h) :p{h.p} { h.p=nullptr; };   //transfer ownership
        Handle& operator=(Handle&& h) { delete p; p=h.p; h.p=nullptr; return *this; }  //transfer ownership

        Handle(const Handle&) = delete;    //no copy
        Handle& operator=(const Handle&) = delete;

       //...
    };
  • "स्वामित्व हस्तांतरण" का क्या अर्थ है?
  • कॉपी ctor " हटाएं " के बराबर क्यों है? यह कैसे उपयोगी है?

कृपया अगर कोई स्पष्टीकरण के साथ कुछ उदाहरण जोड़ सकता है, तो यह एक बड़ी मदद होगी।

1
जोड़ा संपादित
विचारों: 1
संभावित अर्थात् क्या चल रहा है? का संभावित डुप्लिकेट
जोड़ा लेखक Mike Seymour, स्रोत
इस वीडियो को देखें: channel9.msdn.com/Events/GoingNative/2013/& hellip;
जोड़ा लेखक Raxvan, स्रोत
यह एक कॉपी ctor नहीं है यह एक चाल ctor है।
जोड़ा लेखक PeterT, स्रोत

3 उत्तर

It's a move constructor, the special && syntax introduced in C++11 takes a rvalue reference, so a reference to a variable which has no name and can't be referenced anywhere else inside the code.

कन्स्ट्रक्टर में क्या होता है कि हैंडल चलने वाले कन्स्ट्रक्टर के माध्यम से हैंडल का स्वामित्व लेता है जिस तरह से यह चोरी करता है (मुझे पास करें शब्द) टी * पी </कोड> अपने वैल्यू को अपने वैरिएबल को असाइन करके और फिर nullptr को पास किए गए रावल्यू के चर पर सेट करके अंदर रखें।

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

1
जोड़ा

सी ++ में आपके पास प्रतिलिपि बनाने वाले और कॉपी ऑपरेटरों की प्रतिलिपि थी, जो आपकी वस्तु बड़ी थीं, जो महंगी थीं। अब सी ++ 11 में आपने कन्स्ट्रक्टर को स्थानांतरित किया है और ऑपरेटर को ले जाया है जो कहता है "स्रोत से सबकुछ लें और इसे मार दें"।

mybigthing y ;
...
mybigthing x( move(y)) ;

वाई आंतरिक रूप से बहुत सारी चीजों के साथ बनाया गया है। एक्स (वाई) के बाद, वाई अब खाली है और सभी बड़ी चीजें एक्स में हैं।

इसके मुख्य कारणों में से एक है कार्यों से मुक्त वस्तुओं को मुक्त करना:

mybigthing f()
{
  mybigthing tmp ;
  ...
  return tmp ;
}

{
  mybigthing y= f() ;
}

सी ++ 03 में, यह भयानक प्रदर्शन के रूप में होगा। अब यह मुफ़्त है। कंपाइलर्स को वास्तव में y कोड का उपयोग f() के अंदर अस्थायी रूप से करने की आवश्यकता होती है और कभी भी कोई प्रतियां नहीं होती हैं।

0
जोड़ा

आपके दूसरे प्रश्न के बारे में: प्रतिलिपि ctor "हटाएं" के बराबर क्यों है? यह कैसे उपयोगी है?

Here is an answer: http://www.developerfusion.com/article/133063/constructors-in-c11/

सी ++ 11 स्पष्ट रूप से हटाए गए रचनाकार

     

सी ++ 11 स्पष्ट रूप से हटाए गए कन्स्ट्रक्टर की अवधारणा का भी समर्थन करता है।   उदाहरण के लिए, आप एक कक्षा को परिभाषित कर सकते हैं जिसके लिए आप लिखना नहीं चाहते हैं   कोई भी निर्माता और आप यह भी नहीं चाहते कि संकलक उत्पन्न करे   डिफ़ॉल्ट कन्स्ट्रक्टर। उस स्थिति में आपको स्पष्ट रूप से हटा देना होगा   डिफ़ॉल्ट कन्स्ट्रक्टर:

     <�पी> कक्षा MyClass {सार्वजनिक:       MyClass() = हटाएं; };
0
जोड़ा
धन्यवाद !! इसके सहायक और सूचनात्मक
जोड़ा लेखक user2598064, स्रोत