कंस्ट्रक्टर और सेटर के मान से गुजरने के लिए शैक्षिक कार्यक्रम (आधुनिक C ++, उदाहरण)

अगली पोस्ट में habr.com/en/post/460831/#comment_20416435 टिप्पणियों और वहां सामने आई चर्चा को देखते हुए, कि कैसे कंस्ट्रक्टर या सेटर को सही ढंग से पास करने के बारे में लेख Habré में बाधा नहीं बनेगा। StackOverflow में बहुत सी समान सामग्री है, लेकिन मुझे यहाँ कुछ याद नहीं है।

क्योंकि उस लेख में उदाहरण पूरी तरह से सही है, और लेख का लेखक बिल्कुल सही है। यहाँ एक उदाहरण है:

// . struct person { person(std::string first_name, std::string last_name) : first_name{std::move(first_name)} //  , last_name{std::move(last_name)} // std::move  ! {} private: std::string first_name; std::string last_name; }; 

ऐसा कोड आपको कक्षा का उपयोग करने के लिए सभी (अच्छी तरह से, लगभग सभी) संभावित विकल्पों को कवर करने की अनुमति देता है:

 std::string first{"abc"}, last{"def"}; person p1{first, last}; // (1)    person p2{std::move(first), last}; // !!!    person p2{std::move(first), std::move(last)}; // (3)   person p3{"x", "y"}; //   

पुरानी विधि के साथ तुलना करें, जब कब्ज से गुजरा और: यह निश्चित रूप से खराब है, क्योंकि यह विकल्प (3) को बाहर करता है:

 // . struct person { person(const std::string& first_name, const std::string& last_name) : first_name{first_name} , last_name{last_name} {} private: std::string first_name; std::string last_name; }; std::string first{"abc"}, last{"def"}; person p1{first, last}; //  ,    //      ,  first  last    // ?         //   0 !  const& . 

&& के साथ एक विकल्प भी बदतर है, लेकिन विपरीत दिशा में:

 // . struct person { person(std::string&& first_name, std::string&& last_name) : first_name{std::move(first_name)} , last_name{std::move(last_name)} {} private: std::string first_name; std::string last_name; }; std::string first{"abc"}, last{"def"}; person p1{std::move(first), std::move(last)}; //  //       ,    &&  : person p2{std::string{first}, std::string{last}}; // FOOOO 

यदि आप एक दहनशील विस्फोट से डरते नहीं हैं, तो आप && को एक मौका दे सकते हैं (लेकिन क्यों? गति में कोई वास्तविक लाभ नहीं होगा, ऑप्टिमाइज़र बंद नहीं करता है):

 //   . struct person { person(std::string&& first_name, std::string&& last_name) : first_name{std::move(first_name)} , last_name{std::move(last_name)} {} person(const std::string& first_name, std::string&& last_name) : first_name{first_name} , last_name{std::move(last_name)} {} person(std::string&& first_name, const std::string& last_name) : first_name{std::move(first_name)} , last_name{last_name} {} person(const std::string& first_name, const std::string& last_name) : first_name{first_name} , last_name{last_name} {} private: std::string first_name; std::string last_name; }; 

या एक ही बात, केवल टेम्पलेट्स के साथ (लेकिन फिर से, क्यों?):

 //     (   ),      . struct person { template <typename T1, typename T2> person(T1&& first_name, T2&& last_name) : first_name{std::forward<T1>(first_name)} , last_name{std::forward<T2>(last_name)} {} private: std::string first_name; std::string last_name; }; 

यहां तक ​​कि अगर आपके पास std :: string नहीं है, लेकिन आपकी खुद की लिखी हुई बड़ी कक्षा की कुछ वस्तु, और आप चाहते हैं कि लोग इसे स्थानांतरित करें (और कॉपी न करें), तो इस मामले में कंस्ट्रक्टर को इस बड़े वर्ग से कॉपी करने से रोकने के लिए बेहतर है कि इसे हर जगह से पारित किया जाए। द्वारा &&। यह अधिक विश्वसनीय है, और कोड छोटा है।

अंत में, कैसे काम न करें, इस बारे में कुछ विकल्प:

 // . struct person { person(const std::string& first_name, const std::string& last_name) : first_name{first_name} , last_name{last_name} {} private: //   :  ,     //     const std::string& first_name; const std::string& last_name; }; person p{"x", "y"}; // --,  

और ऐसा नहीं है:

 // . struct person { person(std::string& first_name, std::string& last_name) : first_name{first_name} , last_name{last_name} {} private: //   ,      shared_ptr: //  ,   std::string& first_name; std::string& last_name; }; 

ऐसा क्यों हो रहा है, मूल सिद्धांत क्या है? यह सरल है: एक वस्तु, एक नियम के रूप में, इसके गुणों को छोड़ना चाहिए।

यदि वस्तु कुछ खुद करना नहीं चाहती है, तो वह इस "कुछ" के लिए खुद को साझा कर सकती है। वैसे, इस मामले में share_ptr को भी मूल्य से पारित किया जाना चाहिए, और निरंतर लिंक द्वारा नहीं - लेख की शुरुआत में बहुत पहले उदाहरण के साथ कोई अंतर नहीं है:

 //  (  ). struct person { person(std::shared_ptr<portfolio> pf) : pf{std::move(pf)} // std::move     {} private: std::shared_ptr<portfolio> pf; }; auto psh = std::make_shared<portfolio>("xxx", "yyy", "zzz"); ... person p1{psh}; person p2{std::move(psh)}; // (X)  ,  psh    

कृपया ध्यान दें: std :: share_ptr के लिए कदम पूरी तरह से कानूनी है, यह मेमोरी में शेयर्ड_ptr लिंक काउंटर (CPU के सैकड़ों) और उसके इंक्रीमेंट को लॉक करने के ओवरहेड को समाप्त करता है। यह वस्तु के जीवनकाल और उससे जुड़ी अन्य कड़ियों को प्रभावित नहीं करता है। लेकिन (एक्स), निश्चित रूप से किया जा सकता है, केवल अगर नीचे दिए गए कोड में psh लिंक की आवश्यकता नहीं है।

Moral: सामान्य रूप से const & का उपयोग न करें। परिस्थितियों के अनुसार देखो।

पुनश्च
निर्माण पैरामीटर पारित करते समय () के बजाय {} का उपयोग करें। फैशनेबल, आधुनिक, युवा।

पी पी एस
अंत में, एक और बात: std :: move () वास्तव में कुछ भी स्थानांतरित नहीं होता है और अपने आप में शून्य कोडांतरक निर्देशों का अनुवाद करता है। सभी कि std :: move () लिंक पर एक विशेष "चिपचिपा लेबल" लगाना है, इसे एक && - rvalue सन्दर्भ में बदलना है। और आगे इस लेबल के साथ फ़ंक्शन पैरामीटर के प्रकार को "मेल" करना संभव है (उदाहरण के लिए, && - पैरामीटर के लिए एक अलग फ़ंक्शन अधिभार और -parameter के लिए एक अलग)। && - लेबल का अर्थ कॉलिंग कोड को कॉल करने के लिए सक्षम करना है: "यदि आप चाहें, तो आप इस लिंक से मूल्य खा सकते हैं, मुझे अब इसकी आवश्यकता नहीं है; लेकिन केवल अगर आप खाते हैं, हड्डियों को छोड़ देते हैं, तो मुझे अभी भी शेष कंकाल के लिए विध्वंसक को कॉल करने की आवश्यकता है। " उसी सफलता के साथ, साधारण & -लिंक्स प्रसारित करना संभव होगा (आप वस्तु का उपयोग "उन्हें खाने" के लिए भी कर सकते हैं), लेकिन && शब्दार्थ बेहतर है, क्योंकि आप भ्रमित नहीं करेंगे: जहां आप खा सकते हैं, और जहां आप केवल गंध कर सकते हैं।

इस संबंध में, नाम std :: move () को बेहद असफल के रूप में मान्यता दी जानी चाहिए। इसे std :: eat_me_if_you_want () या std :: bon_appetit () कहना सही होगा। लेकिन std :: Move () छोटा है।