रेफरी-योग्य सदस्य कार्य

इस पोस्ट में मैं एक नए और (यह मेरे लिए लगता है) के बारे में बात करूंगा C ++ की अपेक्षाकृत कम ज्ञात विशेषता - संदर्भ-योग्य सदस्य फ़ंक्शन । मैं आपको ऐसे कार्यों को ओवरलोड करने के नियमों के बारे में बताऊंगा, और उपयोग के उदाहरण के रूप में, मैं आपको बताऊंगा कि कैसे एक और C ++ मुहावरे - RAII का उपयोग करके कार्यान्वित संसाधन प्रबंधन योजना को बेहतर बनाने के लिए Ref-Qualifie d फ़ंक्शन का उपयोग किया जाए।

परिचय

इसलिए, हाल ही में, सी ++ में, लिंक के साथ सदस्य कार्यों को अर्हता प्राप्त करना संभव हो गया है (कम से कम उपस्थिति में यह लिंक की तरह दिखता है)। इन योग्यता अंकों को लंबित किया जा सकता है, संदर्भ के संदर्भों को, योग्यता योग्यता के साथ जोड़ा जा सकता है।

class some_type { void foo() & ; void foo() && ; void foo() const & ; void foo() const && ; }; 

इसकी आवश्यकता क्यों है?

कड़ाई से बोलते हुए, आधिकारिक तौर पर इस सुविधा को थोड़ा अलग तरीके से कहा जाता है, जिसका नाम है "रेफ-क्वालिफायर फॉर * *" या "रिवेल्यू रेफरेंस फॉर * *" । लेकिन यह मुझे लगता है कि यह नाम थोड़ा भ्रमित करने वाला है, क्योंकि ऐसा लग सकता है कि अलग-अलग योग्यता वाले कार्यों को कॉल करते समय ऑब्जेक्ट बदल जाता है। वास्तव में, * यह प्रकार कभी नहीं बदलता है। तो चाल क्या है? और चाल यह है कि इन क्वालीफायर के लिए धन्यवाद यह संभव है कि सदस्य के कार्यों को संदर्भ (अंतराल, अंतराल, आदि) द्वारा अधिभारित किया जाए जिसमें ऑब्जेक्ट का उपयोग किया जाता है।

 int main() { some_type t; t.foo(); // some_type::foo() & some_type().foo(); // some_type::foo() && } 

यह कैसे काम करता है?

सी ++ में शुरू करने के लिए, लंबे समय से सदस्य कार्यों और मुफ्त कार्यों के बीच अधिभार को हल करने के लिए एक तंत्र है। आपको इसकी आवश्यकता क्यों है, आप पूछते हैं, क्योंकि आप समझ सकते हैं कि क्या एक नि: शुल्क फ़ंक्शन या एक वर्ग विधि को कम से कम बाहरी रूप से कहा जाता है, सिंटैक्स के अनुसार, एक मामले में obj.f () , दूसरे में बस एफ () ? तथ्य यह है कि जब ऑपरेटर ओवरलोडिंग की बात आती है, तो अब सिंटैक्स में अंतर नहीं हो सकता है। उदाहरण के लिए

 struct some_type { bool operator == (int) const; }; bool operator == (const some_type& l, long r); void g() { some_type t; int i = 42; t == i; //   ? } 

इस अधिभार को हल करने के लिए, संकलक ने एक अतिरिक्त फ़ंक्शन के साथ एक फ्री फ़ंक्शन के रूप में एक सदस्य फ़ंक्शन प्रस्तुत किया - उस ऑब्जेक्ट का लिंक जो फ़ंक्शन को कॉल कर रहा है और फिर सभी नि: शुल्क फ़ंक्शन के बीच ओवरलोडिंग की अनुमति देता है। इसलिए नवाचार को लागू करने के लिए, केवल पहले से ही मौजूदा व्यवहार को "मोड़" करना आवश्यक था, अर्थात् विभिन्न योग्य सदस्य कार्यों के लिए अधिभार उम्मीदवारों के विभिन्न हस्ताक्षर बनाने के लिए।
मैं कुछ शब्दों के बारे में कहूंगा कि यह तंत्र विशेष रूप से कैसे काम करता है, क्योंकि यह हमेशा स्पष्ट है कि कौन सा कार्य किसी विशेष मामले में ओवरलोडिंग के लिए सबसे अच्छा उम्मीदवार है। पहले उदाहरण से फिर से कोड पर विचार करें।

 class some_type { void foo() & ; // 1 void foo() && ; // 2 void foo() const & ; // 3 void foo() const && ; // 4 }; void g() { some_type().foo(); } 

इस कॉल के लिए, 3 उम्मीदवार उपयुक्त हैं: 2, 3, और 4. उनके बीच हल करने के लिए, मानक में विशेष नियम हैं जो कागज पर क्रिया और जटिल दिखते हैं, लेकिन इसका सार एक फ़ंक्शन का चयन करना है जो सबसे अधिक प्रकार से मेल खाता है।
जैसा कि मैं कल्पना करता हूं, मैं उम्मीदवार के निष्कर्ष पर तर्क की श्रृंखला को फिर से लिखने की कोशिश करूंगा। इस उदाहरण में, अभिव्यक्ति some_type () एक प्रतिद्वंद्विता है । संभावित रूप से, फ़ंक्शंस 2, 3, या 4 को बुलाया जा सकता है। लेकिन रेवल्यू रेफरेंस क्वालिफाइड फ़ंक्शंस कॉन्स्टेंट की तुलना में मूल अभिव्यक्ति (रिवेल्यू) के प्रकार से अधिक "मिलान" किए जाते हैं। विकल्प 2 और 4 बने रहें। चौथे अवतार में, पूर्ण पत्राचार के लिए, आपको मूल प्रकार पर एक अतिरिक्त कार्रवाई करने की आवश्यकता है - कास्ट जोड़ें, जबकि दूसरे संस्करण में कोई अतिरिक्त कार्रवाई की आवश्यकता नहीं है। इसलिए, अंत में, विकल्प 2 का चयन किया जाएगा।

कैसे करें इस्तेमाल?

यह उन मामलों में इस नवाचार का उपयोग करने के लिए स्पष्ट रूप से सुविधाजनक है जब किसी वस्तु का व्यवहार उस संदर्भ से भिन्न होना चाहिए जिसमें इसका उपयोग किया जाता है। उदाहरण के लिए, हम RAII का उपयोग करते समय एक संचित संसाधन के लिए एक संकेतक का उपयोग करने के लिए इसे सुरक्षित बना सकते हैं ।

 class file_wrapper { public: // ... operator FILE* () {return held_;} ~file_wrapper() {fclose(held_);} private: FILE* held_; }; 

इस उदाहरण में, ऑपरेटर फ़ाइल * () फ़ाइल आवरण के सुरक्षित उपयोग में एक विशाल छेद का प्रतिनिधित्व करता है।
उपयोग के इस संदर्भ की कल्पना करें:

 FILE* f = file_wrapper("some_file.txt", "r"); //   f 

अब हमारे पास इसे बनाने का अवसर है, वास्तव में, बहुत सुविधाजनक, कार्य अधिक (लेकिन पूरी तरह से) सुरक्षित नहीं है।

 operator FILE* () & {return held_;} //     lvalue  

आप RAII को थोड़ा अलग तरफ से देख सकते हैं। चूंकि अब हम "समझ" सकते हैं कि वे हमें अलग-अलग संदर्भों में क्या कहते हैं, चलो मामलों में नकल करने के बजाय संसाधन के स्वामित्व को स्थानांतरित करें जहां हमारी वस्तु का उपयोग नहीं किया जाएगा।

 template <typename T> class some_type { public: operator std::unique_ptr<T>() const & { return std::unique_ptr<T>(new T(*held_)); //  } operator std::unique_ptr<T>() && { return std::move(held_); //   } private: std::unique_ptr<T> held_; }; some_type f(); void g() { std::unique_ptr<widget> p = f(); }