SFINAE आसान है

TLDR : यह कैसे निर्धारित किया जाए कि किसी प्रकार के पास किसी दिए गए नाम और हस्ताक्षर के साथ कोई विधि है, और इसके दिमाग को खोए बिना प्रकार के अन्य गुणों को भी पहचानें।

नमस्कार साथियों!
मैं SFINAE के बारे में बात करना चाहता हूं, एक दिलचस्प और बहुत उपयोगी (दुर्भाग्य से *) सी ++ भाषा तंत्र, जो कि, हालांकि, एक अप्रशिक्षित व्यक्ति को बहुत दिमाग तोड़ने वाला लग सकता है। वास्तव में, इसके उपयोग का सिद्धांत काफी सरल और स्पष्ट है, कई स्पष्ट-कट प्रावधानों के रूप में तैयार किया जा रहा है। यह लेख उन पाठकों के लिए है, जिन्हें C ++ में टेम्पलेट का बुनियादी ज्ञान है और जो परिचित हैं, कम से कम टोपी में, C ++ 11 के साथ।
* दुर्भाग्य क्यों? हालांकि SFINAE का उपयोग करना एक दिलचस्प और सुंदर तकनीक है जो एक व्यापक रूप से इस्तेमाल की जाने वाली भाषा के मुहावरे में विकसित हुई है, यह बेहतर होगा कि ऐसे उपकरण हों जो स्पष्ट रूप से प्रकारों के साथ काम करने का वर्णन करते हों।

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

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

• जब यह SFINAE की बात आती है, तो यह जरूरी है कि फ़ंक्शन ओवरलोडिंग के बारे में हो।
• यह कार्य करता है जब फ़ंक्शन तर्कों द्वारा स्वचालित रूप से कटौती की जाती है।
• जब कुछ सिंटैक्स त्रुटि के कारण उन्हें तत्काल नहीं किया जा सकता है तो कुछ ओवरलोड को छोड़ दिया जा सकता है; एक ही समय में संकलन जारी रहता है जैसे कि कुछ भी नहीं हुआ, बिना त्रुटियों के।
• केवल एक टेम्पलेट को खारिज किया जा सकता है।
• SFINAE केवल फ़ंक्शन हेडर पर विचार करता है, फ़ंक्शन बॉडी में त्रुटियों को छोड़ नहीं दिया जाएगा।

यह पता चला है कि हमारे पास कुछ फ़ंक्शन के अधिभार में हेरफेर करने की क्षमता है, उनमें से कुछ को छिपाना अगर कृत्रिम त्रुटियां बनाकर आवश्यक हो। इस मामले में, छिपे हुए उम्मीदवार को एक टेम्पलेट होना चाहिए, और एक त्रुटि का तथ्य इस टेम्पलेट के पैरामीटर पर निर्भर होना चाहिए। कंपाइलर प्रतिस्थापन के बिना अन्य प्रकार की त्रुटियों को पहचानने में सक्षम होगा, खाका की परिभाषा को बमुश्किल देखा जा सकता है, और कोई SFINAE सफल नहीं होगा, लेकिन इसके बजाय हमें दर्द से डांटा जाएगा।

एक साधारण उदाहरण पर विचार करें:

 int difference(int val1, int val2) { return val1 - val2; } template<typename T> typename T::difference_type difference(const T& val1, const T& val2) { return val1 - val2; } 

difference फ़ंक्शन पूर्णांक तर्कों के लिए ठीक काम करता है। लेकिन कस्टम डेटा प्रकारों के साथ, सूक्ष्मताएं शुरू होती हैं। घटाव का परिणाम हमेशा ऑपरेंड के समान नहीं होता है। तो, दो तिथियों का अंतर एक समय अंतराल है, जो अपने आप में एक तिथि नहीं है। यदि कस्टम प्रकार MyDate इसके भीतर एक MyDate परिभाषा है, तो typedef MyInterval difference_type; और घटाव MyInterval operator - (const MyDate& rhs) const; , टेम्पलेट अधिभार उस पर लागू होता है। कॉलिंग difference(date1, date2) टेम्प्लेट अधिभार और संस्करण दोनों को "देखने" में सक्षम होगा difference(date1, date2) को स्वीकार करता है, जबकि टेम्प्लेट अधिभार को अधिक उपयुक्त माना जाएगा।
MyString प्रकार, जिसमें कोई MyString टाइप नहीं है, प्रतिस्थापित किए जाने पर एक त्रुटि का कारण बनेगा: फ़ंक्शन एक नॉन-टाइप प्रकार लौटाएगा। MyString प्रकार के तर्कों के साथ एक difference कॉल केवल एक फ़ंक्शन का एक difference संस्करण "देख" सकता है। यह एकल संस्करण केवल तभी उपयुक्त होगा जब नंबर ऑपरेटर में रूपांतरण MyString में परिभाषित किया गया हो। निर्माण val1 - val2 में एक बाइनरी माइनस ऑपरेटर की उपस्थिति की आवश्यकता होती है और यह सिंटैक्स त्रुटि भी उत्पन्न कर सकता है। यह पता चलता है कि टेम्प्लेट फ़ंक्शन difference एक साथ तीन स्थितियों को पूरा करने के लिए एक साथ तर्क के प्रकार की जांच करता है: अंतर_टाइप की उपस्थिति, घटाव ऑपरेटर की उपस्थिति और प्रकार के difference_type से घटाव के परिणाम की संभावना अंतर_टाइप (रूपांतरण return द्वारा निहित है)। लेकिन पहली स्थिति का उल्लंघन करने वाले प्रकारों के लिए, यह अधिभार दिखाई नहीं देता है, दूसरी या तीसरी स्थितियों का उल्लंघन संकलन त्रुटि का कारण होगा।

आइए यह पता लगाने की कोशिश करें कि एक मेटाफ़ंक्शन कैसे बनाया जाए जो हमें बताता है कि void foo(int) विधि किसी प्रकार में है। एसटीएल की देखभाल, विशेष रूप से संस्करण सी ++ 11 के साथ शुरू करना, यह पहले से ही हमारे लिए कई उपयोगी मेटाफंक्शंस की पहचान कर चुका है जो मुख्य रूप से type_traits और limits हेडर में स्थित हैं, हालांकि किसी कारण से हम वास्तव में क्या करने का फैसला करते हैं, यह बिल्कुल नहीं है। एक मेटाफ़ंक्शन आमतौर पर डेटा के बिना एक टेम्प्लेट संरचना की तरह दिखता है, जिसके अंदर ऑपरेशन का परिणाम परिभाषित होता है: टाइपडिफ द्वारा निर्दिष्ट type या स्थिर स्थिर value । एसटीएल इस तरह के एक समझौते का पालन करता है, और हमारे पास मूल होने का कोई कारण नहीं है, इसलिए हम स्थापित मॉडल का पालन करेंगे।

आप तुरंत हमारे भविष्य के मेटाफ़ंक्शन का "कंकाल" लिख सकते हैं:

 template<typename T> struct has_foo{}; 

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

 template<typename T> struct has_foo{ static constexpr bool value = true; //  ,   ,     "". }; 

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

 template<typename T> struct has_foo{ void detect(...); //  ""  . static constexpr bool value = true; // -,   ! }; 

अब आपको "डिटेक्टर" घोषित करने की आवश्यकता है। यह एक टेम्पलेट होना चाहिए: तथ्य यह है कि यह पहले से ही टेम्पलेट संरचना के अंदर है पर्याप्त नहीं है! हमें टेम्प्लेट के अंदर एक टेम्प्लेट की आवश्यकता है [हम कुछ ही सेकंड्स के लिए फिल्म इंसेप्शन के नायकों से झलक पाने का आनंद लेते हैं] यह "बैकिंग" पर लागू नहीं होता, क्योंकि हम इसे कभी नहीं फेंकेंगे। लेकिन "डिटेक्टर" के लिए हम जादू शब्द decltype उपयोग करते हैं, जो अभिव्यक्ति के प्रकार को निर्धारित करता है, और स्वयं अभिव्यक्ति की गणना नहीं की जाती है और कोड में अनुवाद नहीं किया जाता है। हम वांछित प्रकार के तर्कों के साथ एक ही विधि की अभिव्यक्ति के रूप में प्रतिस्थापित करते हैं। फिर decltype उत्तर विधि का रिटर्न प्रकार होगा। और अगर उस नाम के साथ कोई विधि नहीं है, या यह अन्य प्रकार के तर्क लेता है, तो हमें वही नियंत्रित त्रुटि मिलती है जो हम चाहते थे। "डिटेक्टर" को foo के समान लौटाएं:

 template<typename T> struct has_foo{ void detect(...); template<typename U> decltype(U().foo(42)) detect(const U&); static constexpr bool value = true; //   ! }; 

यदि हम detect लिए const T& संदर्भ देते हैं, तो यह पता चलता है कि U , const T& के समान है T लौटाए गए मूल्य के प्रकार के पत्राचार की जांच करने के लिए, हम बाद में डिटेक्टर में सुधार करेंगे या रास्ते में कुछ और लेकर आएंगे।
लेकिन रुकिए! हम नए सिरे से निर्मित अनाम वस्तु पर विधि कहते हैं, और यह डिफ़ॉल्ट रूप से निर्मित होता है। लेकिन क्या होगा यदि हम has_foo प्रकार का पास करें has_foo का कोई डिफ़ॉल्ट निर्माता नहीं है? बेशक, एक संकलन त्रुटि। कुछ फ़ंक्शन को घोषित करने के लिए अधिक सही होगा जो वांछित प्रकार का मान लौटाता है। इसे वैसे भी नहीं कहा जाएगा, और वांछित प्रभाव प्राप्त किया जाएगा। एसटीएल ने इस बात का भी ध्यान रखा: utility हेडर में declval फंक्शन है:

 template<typename T> struct has_foo{ void detect(...); template<typename U> decltype(std::declval<U>().foo(42)) detect(const U&); static constexpr bool value = true; //  ! }; 

यह केवल "डिटेक्टर" से "सब्सट्रेट" को भेद करना सीखना बाकी है। यहां वही decltype हमारी मदद करेगा। "सब्सट्रेट" में वापसी प्रकार हमेशा void होता void , और "डिटेक्टर" में विधि द्वारा लौटाया गया प्रकार होता है, अर्थात, जब विधि हमारी आवश्यकताओं को पूरा करती है ... समान void । यह काम नहीं किया हम "सब्सट्रेट" के प्रकार को int बदल देंगे। फिर चेक सरल है: यदि ऑब्जेक्ट T पर detect कॉल टाइप void , तो "डिटेक्टर" ने काम किया है और विधि पूरी तरह से हमारी आवश्यकताओं का अनुपालन करती है। यदि प्रकार अलग है, तो या तो "सब्सट्रेट" काम किया, या विधि मौजूद है, उसी तर्क को स्वीकार करता है, लेकिन कुछ गलत देता है। हम जाँचते हैं कि एसटीएल कितना सावधान है, और फिर हम is_same समानता के लिए जाँच के प्रकार को is_same :

 template<typename T> struct has_foo{ private: //     . static int detect(...); //     . template<typename U> static decltype(std::declval<U>().foo(42)) detect(const U&); public: static constexpr bool value = std::is_same<void, decltype(detect(std::declval<T>()))>::value; //  , . }; 

हुर्रे, हमने वांछित हासिल किया है। जैसा कि आप देख सकते हैं, सब कुछ वास्तव में काफी सरल है। हम उन प्रोग्रामरों को श्रद्धांजलि अर्पित करते हैं, जो पिछले मानक की कठोर परिस्थितियों में इस चाल को करने में कामयाब रहे, declval रूप में ऐसी उपयोगी चीजों की कमी के कारण बहुत अधिक declval और सरल।

SFINAE इतना व्यापक रूप से उपयोग किया जाता है कि यहां तक ​​कि देखभाल करने वाले STL में विशेष enable_if मेटाफ़ंक्शन भी शामिल है। इसके पैरामीटर बुलियन स्थिर और प्रकार हैं (डिफ़ॉल्ट रूप से void )। यदि true पास है, तो मेटाफ़ंक्शन में टाइप type मौजूद है: दूसरा पैरामीटर द्वारा पारित किया गया। यदि false पारित किया जाता है, तो वहां कोई type नहीं है, जो बहुत नियंत्रित त्रुटि पैदा करता है। एक स्वच्छ छोटी सूची में ऊपर सूचीबद्ध विचारों के प्रकाश में, किसी को यह याद रखना चाहिए कि enable_if फ़ंक्शन ओवरलोड को केवल "हटाने" में सक्षम होगा यदि यह एक टेम्पलेट है, और यह भी सुनिश्चित करें कि "अचिह्नित" अधिभार की सूची कभी भी पूरी तरह से खाली नहीं रहती है। आप टेम्पलेट वर्ग की enable_if में enable_if का उपयोग कर सकते हैं, लेकिन इस मामले में यह SFINAE नहीं है, लेकिन कुछ भी जैसे static_assert ।

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