टेम्प्लेट जादू, मेटाफ़ंक्शन IsValidExpression

अच्छा दिन, प्रिय हेब्रोसोसिटी।



आज मैं एक दिलचस्प ट्रिक साझा करना चाहता हूं जिससे आप किसी विशेष अभिव्यक्ति की योग्यता निर्धारित कर सकते हैं।



एक उदाहरण:

/ * हम HasF मेटाफ़ंक्शन को परिभाषित करते हैं, जो हमें किसी भी वर्ग के लिए f () फ़ंक्शन के अस्तित्व को निर्धारित करने की अनुमति देता है। * /

DECLARE_IS_VALID_EXPRESSION (

HasF,

( ( U * ) NULL ) - > f ( ) / * यह अभिव्यक्ति केवल तभी संकलित की जाती है यदि U :: f () * / ) मौजूद है ;



संरचना फू { शून्य एफ ( ) ; } ;

संरचना बार { } ;



BOOST_STATIC_ASSERT ( HasF <A> :: मूल्य ) ; / * यहाँ हसफ़ <A> :: मूल्य सही होगा * /

BOOST_STATIC_ASSERT ( ! हैस < B > :: मूल्य ) ; / * यहाँ हसफ़ <A> :: मूल्य गलत होगा * /

जैसा कि आप शायद पहले ही अनुमान लगा चुके हैं, हम सोचेंगे कि मैक्रो DECLARE_IS_VALID_EXPRESSION कैसे लिखें।



इसलिए, हमारा लक्ष्य यह निर्धारित करना सीखना है कि कोई अभिव्यक्ति संकलित है या नहीं। इस मामले में, संकलक, निश्चित रूप से, किसी भी त्रुटि का उत्पादन नहीं करना चाहिए: एक स्थिरांक को केवल 0 के मान के साथ उत्पन्न किया जाना चाहिए, यदि अभिव्यक्ति संकलित नहीं है, और 1 अन्यथा का मान।

Relizatsiya

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



यह निम्नलिखित कोड काम करता है:

$ DECLARE_IS_VALID_EXPRESSION परिभाषित करें ( नाम, U_BASED_RUNTIME_EXPRESSION ) \

टेम्पलेट < वर्ग T > \

संरचना NAME \

{ \ _

/ * हमें कुछ प्रकार की आवश्यकता है जो निश्चित रूप से तुलना के लिए T नहीं है * / \

संरचना सीडीमी { } ; \

\

/ * यह अधिभार तभी काम करेगा जब U_BASED_RUNTIME_EXPRESSION में "त्रुटियां" नहीं होंगी

** अन्यथा, इस अधिभार को SFINAE के अनुसार नजरअंदाज कर दिया जाएगा। * * \ _

टेम्पलेट < टाइपनेम U > \

स्थिर घोषणा ( U_BASED_RUNTIME_EXPRESSION ) F ( शून्य * ) ; \

\

/ * लेकिन यह अधिभार हमेशा मौजूद है, लेकिन इसकी प्राथमिकता कम है, क्योंकि दीर्घवृत्त * / \

टेम्पलेट < टाइपनेम U > \

स्थिर सीडीमी एफ ( ... ) ; \

\

/ * यह टाईपडेफ़ मौजूद नहीं हो सकता है, लेकिन इसके बिना यह वर्ग सही तरीके से काम नहीं करता है :(

** (विजुअल स्टूडियो टीम के परीक्षकों को शुभकामनाएँ भेजने का अवसर लेते हुए) * / \

टाइपडिफ घोषणापत्र ( F < T > ( nullptr ) ) \

TDummy; \

\

एनम \ _

{ \ _

यदि U_BASED_RUNTIME_EXPRESSION में "त्रुटियां" और 0 अन्यथा नहीं हैं तो / * मान 1 होगा

** क्यों? \

** यदि कोई "त्रुटियां" नहीं हैं, तो F के दोनों संस्करण मौजूद हैं, और F <T> (nullptr) उस का चयन करें: \

** जिसमें कोई दीर्घवृत्त नहीं है, अर्थात्। हमारे परीक्षण की अभिव्यक्ति के साथ, और इसकी वापसी प्रकार नहीं है

** सीडीमी नहीं, क्योंकि सीडीमी को स्थानीय रूप से घोषित किया गया है। \

** यदि "त्रुटियां" हैं, तो परीक्षण किए गए अभिव्यक्ति के साथ विकल्प एफ को बाहर निकाल दिया जाएगा, और, \ _

** तदनुसार, F <T> (nullptr) दूसरा अधिभार (जो सीडीमी लौटाता है) का चयन करेगा * / \

मान = ! बढ़ावा देना :: is_same < CDummy, TDummy > :: value \

} ; \

} ;

यह कार्यान्वयन, दुर्भाग्य से, C ++ 0x की आवश्यकता है (मेरा संकलक VC10 है)। नए मानक के बिना ऐसा करना सैद्धांतिक रूप से संभव है (विचार समान है, लेकिन आकार का उपयोग घोषणा के बजाय किया जाता है)। लेकिन! यहाँ फिर से, मैं Microsoft परीक्षकों को नमस्ते कहना चाहता हूँ, जैसा कि sizeof टेम्पलेट परिभाषा क्षेत्र में सही ढंग से काम नहीं करता है - यह वहां "अपेक्षित" नहीं है (यदि मुझे सही याद है)। जीसीसी में, आकार पर समाधान ठीक काम करता है।

आवेदन

उदाहरण के लिए, निम्न कोड एक उदाहरण के रूप में काम कर सकता है:

/ * मेटाफ़ंक्शन को परिभाषित करता है IsStreamSerializationSupported, जो वापस लौटता है

** यह सच है कि यदि तर्क धाराओं के माध्यम से इनपुट / आउटपुट का समर्थन करता है * /

DECLARE_IS_VALID_EXPRESSION (

IsStreamSerializationSupported,

( ( std :: cout << * ( U * ) NULL ) , ( std :: cin >> * ( U * ) NULL ) ; ) ;



/ * डबल समर्थन करता है इनपुट / आउटपुट स्ट्रीम के माध्यम से "बॉक्स से बाहर" * /

BOOST_STATIC_ASSERT ( IsStreamSerializationSupported < double > :: value ) ;



संरचना फू { } ;



/ * लेकिन धाराओं के माध्यम से फू इनपुट / आउटपुट समर्थन नहीं करता है :( * /

BOOST_STATIC_ASSERT ( ! IsStreamSerializationSupported < Foo > :: value ) ;



संरचना बार { } ;



टेम्पलेट < वर्ग TChar, वर्ग लक्षण >

std :: basic_ostream < TChar, लक्षण > और ऑपरेटर << (

std :: basic_ostream < TChar, Traits > & , const Bar & ) ;



टेम्पलेट < वर्ग TChar, वर्ग लक्षण >

std :: basic_istream < TChar, लक्षण > और ऑपरेटर >> (

std :: basic_istream < TChar, Traits > & , Bar & ) ;



/ * बार धाराओं के माध्यम से I / O का समर्थन करता है, जैसा कि संगत ऑपरेटरों को परिभाषित किया गया है। * /

BOOST_STATIC_ASSERT ( IsStreamSerializationSupported < Bar > :: value ) ;

ऐसी चीजें सत्यापित करने में मदद करती हैं कि टेम्पलेट को दिया गया प्रकार विभिन्न अवधारणाओं से मेल खाता है (इस मामले में, अवधारणा से मिलान करने के लिए स्ट्रीम के माध्यम से इनपुट को इनपुट / आउटपुट का समर्थन करना चाहिए)।



इसके लिए मैं अलविदा कहता हूं, आप सभी का ध्यान देने के लिए धन्यवाद! :)