कैसे SFINAE चिकना और विश्वसनीय बनाने के लिए

फिर से नमस्कार। हम आपके साथ एक दिलचस्प लेख साझा कर रहे हैं, जिसका एक अनुवाद विशेष रूप से पाठ्यक्रम "C ++ डेवलपर" के छात्रों के लिए तैयार किया गया था।

---

आज हमारे पास Balázs द्वारा एक अतिथि पोस्ट है। एडम Verizon स्मार्ट कम्युनिटीज़ हंगरी में एक सॉफ्टवेयर इंजीनियर है और एम्बेडेड सिस्टम के लिए वीडियो एनालिटिक्स विकसित करता है। उनका एक जुनून संकलन समय का अनुकूलन है, इसलिए वह तुरंत इस विषय पर एक अतिथि पोस्ट लिखने के लिए सहमत हुए। आप एडम को लिंक्डइन पर ऑनलाइन पा सकते हैं।

SFINAE को सुरुचिपूर्ण बनाने के लिए लेखों की एक श्रृंखला में , हमने देखा कि कैसे हमारे SFINAE टेम्पलेट को बहुत संक्षिप्त और अभिव्यंजक बनाया जाए ।

बस इसके मूल रूप पर एक नज़र डालें:

template<typename T> class MyClass { public: void MyClass(T const& x){} template<typename T_ = T> void f(T&& x, typename std::enable_if<!std::is_reference<T_>::value, std::nullptr_t>::type = nullptr){} }; 

और इसे इस अधिक अभिव्यंजक रूप से तुलना करें:

 template<typename T> using IsNotReference = std::enable_if_t<!std::is_reference_v<T>>; template<typename T> class MyClass { public: void f(T const& x){} template<typename T_ = T, typename = IsNotReference <T_>> void f(T&& x){} }; 

हम यथोचित रूप से विश्वास कर सकते हैं कि उत्पादन में इसका उपयोग करना और आराम करना पहले से ही संभव है। हम कर सकते हैं, यह ज्यादातर मामलों में काम करता है, लेकिन - जैसा कि हम इंटरफेस के बारे में बात करते हैं - हमारा कोड सुरक्षित और विश्वसनीय होना चाहिए। क्या ऐसा है? चलो इसे हैक करने की कोशिश करते हैं!

दोष # 1: SFINAE को बायपास किया जा सकता है

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

 template< typename T > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } int main() { int a{ std::numeric_limits< int >::max() }; std::cout << "a: " << a << " myAbs( a ): " << myAbs( a ) << std::endl; } 

यह कार्यक्रम निम्नलिखित प्रदर्शित करता है, जो काफी सामान्य दिखता है:

 a: 2147483647 myAbs( a ): 2147483647 

लेकिन हम अहस्ताक्षरित तर्कों के साथ अपने abs फ़ंक्शन को कॉल कर सकते हैं, और प्रभाव विनाशकारी होगा:

 nt main() { unsigned int a{ std::numeric_limits< unsigned int >::max() }; std::cout << "a: " << a << " myAbs( a ): " << myAbs( a ) << std::endl; } 

दरअसल, अब कार्यक्रम प्रदर्शित करता है:

a: 4294967295 myAbs( a ): 1

हमारे फ़ंक्शन को अहस्ताक्षरित तर्कों के साथ काम करने के लिए डिज़ाइन नहीं किया गया था, इसलिए हमें SFINAE के साथ T के संभावित सेट को सीमित करना चाहिए:

 template< typename T > using IsSigned = std::enable_if_t< std::is_signed_v< T > >; template< typename T, typename = IsSigned< T > > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } 

कोड अपेक्षित रूप से काम करता है: एक अहस्ताक्षरित प्रकार के साथ myAbs पर कॉल करने से संकलन-समय त्रुटि होती है:

candidate template ignored: requirement 'std::is_signed_v< unsigned int>' was not satisfied [with T = unsigned int]

हैकिंग SFINAE राज्य

फिर इस समारोह में क्या गलत है? इस प्रश्न का उत्तर देने के लिए, हमें यह जांचने की आवश्यकता है कि myAbs SFINAE को कैसे लागू करता है।

 template< typename T, typename = IsSigned<T> > T myAbs( T val ); 

myAbs एक फ़ंक्शन टेम्प्लेट है जिसमें दो प्रकार के इनपुट टेम्पलेट पैरामीटर हैं। पहला फ़ंक्शन तर्क का वास्तविक प्रकार है, दूसरा डिफ़ॉल्ट IsSigned < T > (अन्यथा std::enable_if_t < std::is_signed_v < T > > वरना std::enable_if < std::is_signed_v < T>, void>::type , जो void या विफल प्रतिस्थापन है)।

हम myAbs कैसे कह सकते हैं? 3 तरीके हैं:

 int a{ myAbs( -5 ) }; int b{ myAbs< int >( -5 ) }; int c{ myAbs< int, void >( -5 ) }; 

पहली और दूसरी कॉल सीधी है, लेकिन तीसरी दिलचस्प है: void टेम्पलेट का तर्क क्या है?

दूसरा टेम्पलेट पैरामीटर अनाम है, एक डिफ़ॉल्ट प्रकार है, लेकिन यह अभी भी एक टेम्पलेट पैरामीटर है, इसलिए आप इसे स्पष्ट रूप से निर्दिष्ट कर सकते हैं। क्या यह एक समस्या है? इस मामले में, यह वास्तव में एक बड़ी समस्या है। हम अपने SFINAE चेक को पाने के लिए तीसरे फॉर्म का उपयोग कर सकते हैं:

 unsigned int d{ myAbs< unsigned int, void >( 5u ) }; unsigned int e{ myAbs< unsigned int, void >( std::numeric_limits< unsigned int >::max() ) }; 

यह कोड ठीक संकलित करता है, लेकिन विनाशकारी परिणामों की ओर जाता है, जिससे बचने के लिए हमने SFINAE का उपयोग किया:

 a: 4294967295 myAbs( a ): 1 

हम इस समस्या को हल करेंगे - लेकिन पहले: क्या कोई अन्य नुकसान हैं? खैर ...

दोष # 2: हम विशिष्ट कार्यान्वयन नहीं कर सकते

SFINAE का एक अन्य सामान्य उपयोग विशिष्ट संकलन-समय की स्थितियों के लिए विशिष्ट कार्यान्वयन प्रदान करना है। क्या होगा यदि हम myAbs मूल्यों के साथ myAbs की कॉल को पूरी तरह से प्रतिबंधित नहीं करना चाहते हैं और इन मामलों के लिए एक तुच्छ कार्यान्वयन प्रदान करते हैं? हम C ++ 17 में कॉन्स्टैक्सप्र का उपयोग कर सकते हैं (हम बाद में इस पर चर्चा करेंगे), या हम कर सकते हैं:

  template< typename T > using IsSigned = std::enable_if_t< std::is_signed_v< T > >; template< typename T > using IsUnsigned = std::enable_if_t< std::is_unsigned_v< T > >; template< typename T, typename = IsSigned< T > > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } template< typename T, typename = IsUnsigned< T > > T myAbs( T val ) { return val; } 

लेकिन यह क्या है?

 error: template parameter redefines default argument template< typename T, typename = IsUnsigned< T > > note: previous default template argument defined here template< typename T, typename = IsSigned< T > > 

ओह, C ++ मानक (C ++ 17; .117.1.16) निम्नलिखित बताता है :

"एक ही दायरे में दो अलग-अलग घोषणाओं द्वारा टेम्पलेट पैरामीटर को डिफ़ॉल्ट तर्क प्रदान नहीं किए जाने चाहिए।"

ओह, यह ठीक है कि हमने क्या किया ...

अगर नियमित रूप से उपयोग क्यों नहीं करते?

हम इसके बजाय रनटाइम पर उपयोग कर सकते हैं:

 template< typename T > T myAbs( T val ) { if( std::is_signed_v< T > ) { return ( ( val <= -1 ) ? -val : val ); } else { return val; } } 

संकलक स्थिति का अनुकूलन करेगा क्योंकि if (std::is_signed_v < T>) टेम्पलेट बनाने के बाद if (true) या if (false) हो जाता है। हां, myAbs हमारे वर्तमान कार्यान्वयन के myAbs यह काम करेगा। लेकिन कुल मिलाकर, यह एक बहुत बड़ी सीमा निर्धारित करता है: if और else प्रत्येक T लिए मान्य होने चाहिए T क्या होगा यदि हम अपने कार्यान्वयन को थोड़ा बदलते हैं:

 template< typename T > T myAbs( T val ) { if( std::is_signed_v< T > ) { return std::abs( val ); } else { return val; } } int main() { unsigned int a{ myAbs( 5u ) }; } 

हमारा कोड तुरंत दुर्घटनाग्रस्त हो जाएगा:

 error: call of overloaded 'abs(unsigned int&)' is ambiguous 

यह प्रतिबंध वह है जो SFINAE समाप्त करता है: हम वह कोड लिख सकते हैं जो केवल T के सबसेट के लिए मान्य है (myAbs में यह केवल अहस्ताक्षरित प्रकारों के लिए मान्य है या केवल हस्ताक्षरित प्रकारों के लिए मान्य है)।

समाधान: SFINAE के लिए दूसरा रूप

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

यदि हम डिफ़ॉल्ट प्रकार प्रदान करने के बजाय टेम्पलेट पैरामीटर प्रकार घोषित करने के लिए हमारे SFINAE कोड का उपयोग करते हैं तो क्या होगा? आइए कोशिश करते हैं:

 template< typename T > using IsSigned = std::enable_if_t< std::is_signed_v< T >, bool >; template< typename T, IsSigned< T > = true > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } int main() { //int a{ myAbs( 5u ) }; int b{ myAbs< int >( 5u ) }; //int c{ myAbs< unsigned int, true >( 5u ) }; } 

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

 template< typename T, IsSigned< T > = true > 

यह काम करता है! myAbs (5u) कंपाइलर पहले की तरह त्रुटि देता है:

 candidate template ignored: requirement 'std::is_signed_v<unsigned int>' was not satisfied [with T = unsigned int 

दूसरी कॉल, myAbs < int> (5u) अभी भी मान्य है, हम संकलक प्रकार T स्पष्ट रूप से बताते हैं, इसलिए यह 5u को int रूपांतरित करता है।

अंत में, हम अब उंगली के आसपास myAbs पता नहीं लगा सकते हैं: myAbs < unsigned int, true> (5u) एक त्रुटि फेंकता है। इससे कोई फर्क नहीं पड़ता कि हम कॉल में डिफ़ॉल्ट मान प्रदान करते हैं या नहीं, SFINAE अभिव्यक्ति के भाग का मूल्यांकन वैसे भी किया जाता है, क्योंकि संकलक को एक अनाम टेम्पलेट मान के तर्क प्रकार की आवश्यकता होती है।

हम अगली समस्या पर आगे बढ़ सकते हैं - लेकिन एक मिनट रुकिए! मुझे लगता है कि अब हम समान टेम्पलेट पैरामीटर के लिए डिफ़ॉल्ट तर्क को ओवरराइड नहीं करते हैं। मूल स्थिति क्या थी?

 template< typename T, typename = IsUnsigned< T > > T myAbs( T val ); template< typename T, typename = IsSigned< T > > T myAbs( T val ); 

लेकिन अब वर्तमान कोड के साथ:

 template< typename T, IsUnsigned< T > = true > T myAbs( T val ); template< typename T, IsSigned< T > = true > T myAbs( T val ); 

यह पिछले कोड के समान दिखता है, इसलिए हम सोच सकते हैं कि यह या तो काम नहीं करेगा, लेकिन वास्तव में इस कोड में समान समस्या नहीं है। IsUnsigned < T> क्या है? बूल या असफल लुक। और IsSigned < T> क्या है? एक ही बात है, लेकिन अगर उनमें से एक बूल है, तो दूसरा एक असफल लुकअप है।

इसका मतलब है कि हम डिफ़ॉल्ट तर्कों को ओवरराइड नहीं करते हैं, क्योंकि टेम्पलेट तर्क बूल के साथ केवल एक फ़ंक्शन है, दूसरा एक असफल प्रतिस्थापन है, इसलिए यह मौजूद नहीं है।

सिंथेटिक चीनी

युपीडी। इस अनुच्छेद को लेखक द्वारा इसमें मिली त्रुटियों के कारण हटा दिया गया था।

C ++ के पुराने संस्करण

उपरोक्त सभी C ++ 11 के साथ काम करते हैं, एकमात्र अंतर मानक संस्करणों के बीच प्रतिबंधों की परिभाषाओं की क्रियाशीलता है:

 //C++11 template< typename T > using IsSigned = typename std::enable_if< std::is_signed< T >::value, bool >::type; //C++14 - std::enable_if_t template< typename T > using IsSigned = std::enable_if_t< std::is_signed< T >::value, bool >; //C++17 - std::is_signed_v template< typename T > using IsSigned = std::enable_if_t< std::is_signed_v< T >, bool >; 

लेकिन टेम्पलेट वही रहता है:

 template< typename T, IsSigned< T > = true > 

अच्छे पुराने C ++ 98 में, कोई टेम्पलेट उपनाम नहीं हैं, इसके अलावा, फ़ंक्शन टेम्पलेट में प्रकार या डिफ़ॉल्ट मान नहीं हो सकते हैं। हम अपने SFINAE कोड को परिणाम प्रकार या केवल फ़ंक्शन मापदंडों की सूची में सम्मिलित कर सकते हैं। दूसरा विकल्प अनुशंसित है क्योंकि निर्माणकर्ताओं के पास परिणाम प्रकार नहीं हैं। सबसे अच्छा हम कुछ इस तरह कर सकते हैं:

 template< typename T > T myAbs( T val, typename my_enable_if< my_is_signed< T >::value, bool >::type = true ) { return( ( val <= -1 ) ? -val : val ); } 

तुलना के लिए बस - C ++ का आधुनिक संस्करण:

 template< typename T, IsSigned< T > = true > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } 

सी ++ 98 संस्करण बदसूरत है, एक अर्थहीन पैरामीटर का परिचय देता है, लेकिन यह काम करता है - यदि आप बिल्कुल आवश्यक हैं तो आप इसका उपयोग कर सकते हैं। और हां: my_enable_if और my_is_signed को लागू किया जाना चाहिए ( std :: enable_if std :: is_signed C ++ 11 में नए थे)।

वर्तमान स्थिति

C ++ 17 की शुरुआत हुई if constexpr , संकलित समय पर शर्तों के आधार पर कोड को छोड़ने की विधि। अगर और दोनों बयानों को वाक्यविन्यास रूप से सही होना चाहिए, लेकिन हालत का संकलन समय पर मूल्यांकन किया जाएगा।

 template< typename T > T myAbs( T val ) { if constexpr( std::is_signed_v< T > ) { return( ( val <= -1 ) ? -val : val ); } else { if constexpr( std::is_unsigned_v< T > ) { return val; } /*else { static_assert( false, "T must be signed or unsigned arithmetic type." ); }*/ } } 

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

सौभाग्य से, एक खामी है: टेम्पलेट ऑब्जेक्ट्स में, गिराए गए ऑपरेटर नहीं बनाए जाते हैं यदि स्थिति मूल्य से स्वतंत्र है। बहुत बढ़िया!

तो हमारे कोड के साथ एकमात्र समस्या यह है कि यह टेम्पलेट परिभाषा के दौरान क्रैश हो जाता है। यदि हम खाका बनाने के समय तक static_assert के मूल्यांकन को टाल सकते हैं, तो समस्या हल हो जाएगी: यदि हमारी सभी स्थितियाँ झूठी हैं और केवल तभी इसे बनाया जाएगा। लेकिन जब तक टेम्प्लेट नहीं बनाया जाता तब तक हम static_assert को कैसे सुरक्षित कर सकते हैं? इसकी स्थिति प्रकार पर निर्भर करें!

 template< typename > inline constexpr bool dependent_false_v{ false }; template< typename T > T myAbs( T val ) { if constexpr( std::is_signed_v< T > ) { return( ( val <= -1 ) ? -val : val ); } else { if constexpr( std::is_unsigned_v< T > ) { return val; } else { static_assert( dependent_false_v< T >, "Unsupported type" ); } } } 

भविष्य के बारे में

हम वास्तव में पहले से ही करीब हैं, लेकिन हमें थोड़ी प्रतीक्षा करने की आवश्यकता है जब तक कि सी ++ 20 अंतिम समाधान नहीं लाता है: अवधारणाएं! यह टेम्पलेट (और SFINAE) का उपयोग करने के तरीके को पूरी तरह से बदल देगा।

संक्षेप में: अवधारणाओं का उपयोग उन तर्कों के सेट को सीमित करने के लिए किया जा सकता है जो टेम्पलेट मापदंडों के लिए स्वीकार किए जाते हैं। हमारे एब्स फ़ंक्शन के लिए, हम निम्नलिखित अवधारणा का उपयोग कर सकते हैं:

 template< typename T > concept bool Arithmetic() { return std::is_arithmetic_v< T >; } 

और हम अवधारणाओं का उपयोग कैसे कर सकते हैं? इसके तीन तरीके हैं:

 //   template< typename T > requires Arithmetic< T >() T myAbs( T val ); //   template< Arithmetic T > T myAbs( T val ); //  Arithmetic myAbs( Arithmetic val ); 

ध्यान दें कि तीसरा रूप अभी भी एक टेम्पलेट फ़ंक्शन घोषित करता है! यहाँ C ++ 20 में myAbs का पूर्ण कार्यान्वयन है:

 template< typename T > concept bool Arithmetic() { return std::is_arithmetic_v< T >; } Arithmetic myAbs( Arithmetic val ) { if constexpr( std::is_signed_v< decltype( val ) > ) { return( ( val <= -1 ) ? -val : val ); } else { return val; } } int main() { unsigned int a{ myAbs( 5u ) }; int b{ myAbs< int >( 5u ) }; //std::string c{ myAbs( "d" ) }; } 

एक टिप्पणी की गई कॉल निम्न त्रुटि देती है:

 error: cannot call function 'auto myAbs(auto:1) [with auto:1 = const char*]' constraints not satisfied within 'template<class T> concept bool Arithmetic() [with T = const char*]' concept bool Arithmetic(){ ^~~~~~~~~~ 'std::is_arithmetic_v' evaluated to false 

मैं सभी से आग्रह करता हूं कि उत्पादन विधि में इन विधियों का साहसपूर्वक उपयोग करें; संकलन समय रनटाइम से सस्ता है। हैप्पी SFINAEing!