सी ++ 11 में कॉपी/मूव/ऑपरेटर = त्रिकोणीय लिखने का "सही" तरीका क्या है?

Question

इस बिंदु पर, कॉपी कन्स्ट्रक्टर और असाइनमेंट ऑपरेटर जोड़ी लिखना अच्छी तरह परिभाषित है; एक त्वरित खोज आपको इन्हें ठीक से कोड करने के तरीके पर बहुत सारी हिट का नेतृत्व करेगी।

अब चालक कन्स्ट्रक्टर मिश्रण में प्रवेश कर चुका है, क्या कोई नया "सर्वश्रेष्ठ" तरीका है?

Answer 1

अधिमानतः, वे सिर्फ = default; हो जाएगा, के बाद से सदस्य प्रकार std::unique_ptr की तरह, संसाधन प्रबंधन के प्रकार है कि आप से कदम विवरण को छिपाना का होना चाहिए। केवल "निम्न स्तर" प्रकार के कार्यान्वयनकर्ताओं से निपटने के साथ परेशान होना चाहिए।

याद रखें कि यदि आप बाहरी (आपके ऑब्जेक्ट) संसाधन को धारण कर रहे हैं तो आपको केवल हिल अर्थशास्त्र से परेशान करने की आवश्यकता है। यह "फ्लैट" प्रकारों के लिए पूरी तरह बेकार है।

Answer 2

यही वह है जो मैंने साथ आया है, लेकिन मुझे नहीं पता कि वहां एक और इष्टतम समाधान है या नहीं।

class MyClass 
{ 
    void Swap(MyClass &other) 
    { 
     std::swap(other.member, member); 
    } 

public: 
    MyClass() 
     : member() 
    { 
    } 

    MyClass(const MyClass &other) 
     : member(other.member) 
    { 
    } 

    MyClass(MyClass &&other) 
     : member(std::move(other.member)) 
    { 
    } 

    MyClass &operator=(MyClass other) 
    { 
     other.Swap(*this); 
     return *this; 
    } 

private: 
    int member; 
}; 

Answer 3

सबसे अच्छा तरीका यह है कि संकलक उन्हें सभी उत्पन्न करने दें। यह सी ++ 03 में भी सबसे अच्छा तरीका था और यदि आप ऐसा करने में कामयाब रहे हैं तो आप C++ 03 कक्षाएं स्वचालित रूप से "चाल-सक्षम" बन जाते हैं जब आप C++ 11 पर माइग्रेट करते हैं।

अधिकांश संसाधन प्रबंधन मुद्दों को केवल गैर-प्रतिलिपि बनाने वाले और एकल संसाधन प्रबंधन वर्गों के विनाशकों को लिखकर हल किया जा सकता है और फिर इनका उपयोग करके समग्र कक्षाएं बना सकते हैं, साथ ही स्मार्ट पॉइंटर्स (उदाहरण के लिए std::unique_ptr) और कंटेनर कक्षाएं अमीर वस्तुओं का निर्माण करने के लिए ।

Answer 4

बजना/libc का उपयोग ++:

#include <chrono> 
#include <iostream> 
#include <vector> 

#if SLOW_DOWN 

class MyClass 
{ 
    void Swap(MyClass &other) 
    { 
     std::swap(other.member, member); 
    } 

public: 
    MyClass() 
     : member() 
    { 
    } 

    MyClass(const MyClass &other) 
     : member(other.member) 
    { 
    } 

    MyClass(MyClass &&other) 
     : member(std::move(other.member)) 
    { 
    } 

    MyClass &operator=(MyClass other) 
    { 
     other.Swap(*this); 
     return *this; 
    } 

private: 
    int member; 
}; 

#else 

class MyClass 
{ 
public: 
    MyClass() 
     : member() 
    { 
    } 

private: 
    int member; 
}; 

#endif 

int main() 
{ 
    typedef std::chrono::high_resolution_clock Clock; 
    typedef std::chrono::duration<float, std::milli> ms; 
    auto t0 = Clock::now(); 
    for (int k = 0; k < 100; ++k) 
    { 
     std::vector<MyClass> v; 
     for (int i = 0; i < 1000000; ++i) 
      v.push_back(MyClass()); 
    } 
    auto t1 = Clock::now(); 
    std::cout << ms(t1-t0).count() << " ms\n"; 
} 

$ clang++ -stdlib=libc++ -std=c++11 -O3 -DSLOW_DOWN test.cpp 
$ a.out 
519.736 ms 
$ a.out 
517.036 ms 
$ a.out 
524.443 ms 

$ clang++ -stdlib=libc++ -std=c++11 -O3 test.cpp 
$ a.out 
463.968 ms 
$ a.out 
458.702 ms 
$ a.out 
464.441 ms 

यह इस परीक्षण पर लगभग 12% की गति अंतर तरह दिखता है।

स्पष्टीकरण: इन परिभाषाओं में से एक में एक छोटी प्रतिलिपि निर्माता और कॉपी असाइनमेंट ऑपरेटर है। दूसरा नहीं है। सी ++ 11 में "ट्रिविअल" का वास्तविक अर्थ है। इसका मतलब है कि कार्यान्वयन को आपकी कक्षा की प्रतिलिपि बनाने के लिए memcpy का उपयोग करने की अनुमति है। या अपनी कक्षा के बड़े सरणी भी कॉपी करने के लिए। तो यदि आप कर सकते हैं तो अपने विशेष सदस्यों को तुच्छ बनाना सबसे अच्छा है। इसका मतलब है कि संकलक उन्हें परिभाषित करने दें। यद्यपि आप चाहें तो भी उन्हें = default के साथ घोषित कर सकते हैं।