मैंने मानक C ++ 11 पुस्तकालय को कैसे लिखा है या बूस्ट इतना डरावना क्यों है। अध्याय 4.1

पिछले भागों का सारांश

सी ++ 11 संकलक का उपयोग करने की क्षमता पर प्रतिबंध के कारण, और वैकल्पिकता की कमी से, बूस्टर ने संकलक के साथ आपूर्ति की गई C ++ 98 / C ++ 03 पुस्तकालय के शीर्ष पर मानक C ++ 11 पुस्तकालय के अपने कार्यान्वयन को लिखना चाहता था।

Static_assert , noexcept , countof को लागू किया गया था, और यह भी, सभी गैर-मानक परिभाषित और संकलक सुविधाओं पर विचार करने के बाद, जानकारी उस कार्यक्षमता के बारे में दिखाई दी जो वर्तमान संकलक द्वारा समर्थित है। नल्टर का अपना कार्यान्वयन शामिल है , जिसे संकलन चरण में चुना गया है।

टाइप_ट्रेट्स और इस "विशेष टेम्पलेट मैजिक" का समय आ गया है।

बेसब्री और गैर-पाठकों के लिए आज के परिणाम के साथ GitHub को लिंक करें:

कमिट और रचनात्मक आलोचना का स्वागत है

"टेम्पलेट जादू" सी ++ की दुनिया में विसर्जित कर दिया।

सामग्री की तालिका

परिचय
अध्याय 1. वीआईएम पर्यवेक्षक वडेंस
अध्याय 2. #ifndef __CPP11_SUPPORT__ #define __COMPILER_SPECIFIC_BUILT_IN_AND_MACRO_HELL__ #endif
अध्याय 3. सही nullptr कार्यान्वयन ढूँढना
अध्याय 4. सी ++ टेम्पलेट मैजिक
.... ४.१ हम छोटे से शुरू करते हैं
.... ४.२ हमारे बारे में कितनी चमत्कारी त्रुटियों का संकलन करता है
.... ४.३ पॉइंटर्स और ऑल-ऑल-ऑल
.... 4.4 टेम्प्लेट लाइब्रेरी के लिए और क्या आवश्यक है
अध्याय 5
...

अध्याय 4. सी ++ टेम्पलेट मैजिक

C ++ 11 कीवर्ड और सभी परिभाषित-निर्भर "स्विच" के साथ उनके कार्यान्वयन के बीच समाप्त होने के बाद, मैंने type_traits भरना शुरू किया। सच में, मेरे पास पहले से ही काफी कुछ मानक कक्षाएं थीं, जो मानक लोगों के समान थीं, जो पहले से ही लंबे समय तक परियोजनाओं में काम करती थीं और इसलिए यह इस सभी को एक ही रूप में लाने के लिए बनी रही, साथ ही साथ लापता कार्यक्षमता को भी जोड़ दिया।

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

४.१ छोटे से शुरू

मैंने std :: integral_constant , std :: bool_constant और इसी तरह के छोटे टेम्पलेट्स के लिए सरल टेम्पलेट्स के साथ शुरुआत की।

template<class _Tp, _Tp Val> struct integral_constant { // convenient template for integral constant types static const _Tp value = Val; typedef const _Tp value_type; typedef integral_constant<_Tp, Val> type; operator value_type() const { // return stored value return (value); } value_type operator()() const { // return stored value return (value); } }; typedef integral_constant<bool, true> true_type; typedef integral_constant<bool, false> false_type; template<bool Val> struct bool_constant : public integral_constant<bool, Val> {}; // Primary template. // Define a member typedef @c type to one of two argument types. template<bool _Cond, class _Iftrue, class _Iffalse> struct conditional { typedef _Iftrue type; }; // Partial specialization for false. template<class _Iftrue, class _Iffalse> struct conditional<false, _Iftrue, _Iffalse> { typedef _Iffalse type; }; 

सशर्त के आधार पर {, "और" "या", "नहीं"} तार्किक कार्यों के लिए सुविधाजनक टेम्पलेट्स दर्ज कर सकते हैं प्रकार के ऊपर (इन सभी कार्यों के संकलन समय पर सीधे होने के लिए बहुत अच्छा है माना जाता है, है ना?):

 namespace detail { struct void_type {}; //typedef void void_type; template<class _B1 = void_type, class _B2 = void_type, class _B3 = void_type, class _B4 = void_type> struct _or_ : public conditional<_B1::value, _B1, _or_<_B2, _or_<_B3, _B4> > >::type { }; template<> struct _or_<void_type, void_type, void_type, void_type>; template<class _B1> struct _or_<_B1, void_type, void_type, void_type> : public _B1 { }; template<class _B1, class _B2> struct _or_<_B1, _B2, void_type, void_type> : public conditional<_B1::value, _B1, _B2>::type { }; template<class _B1, class _B2, class _B3> struct _or_<_B1, _B2, _B3, void_type> : public conditional<_B1::value, _B1, _or_<_B2, _B3> >::type { }; template<class _B1 = void_type, class _B2 = void_type, class _B3 = void_type, class _B4 = void_type> struct _and_; template<> struct _and_<void_type, void_type, void_type, void_type>; template<class _B1> struct _and_<_B1, void_type, void_type, void_type> : public _B1 { }; template<class _B1, class _B2> struct _and_<_B1, _B2, void_type, void_type> : public conditional<_B1::value, _B2, _B1>::type { }; template<class _B1, class _B2, class _B3> struct _and_<_B1, _B2, _B3, void_type> : public conditional<_B1::value, _and_<_B2, _B3>, _B1>::type { }; template<class _Pp> struct _not_ { static const bool value = !bool(_Pp::value); typedef const bool value_type; typedef integral_constant<bool, _not_::value == bool(true)> type; operator value_type() const { // return stored value return (value); } value_type operator()() const { // return stored value return (value); } }; } 

तीन बिंदु यहां ध्यान देने योग्य हैं:

1) टेम्प्लेट के कोण कोष्ठक ('<' और '>') के बीच हमेशा एक स्थान रखना महत्वपूर्ण है, क्योंकि C ++ 11 से पहले मानक में कोई स्पष्टीकरण नहीं था कि ' _ ' और '<<' जैसे कोड की व्याख्या _ _ _ <_ B2 में कैसे करें। _or _ <_ B3, _B4 >> , और इसलिए लगभग सभी कंपाइलरों ने इसे एक बिट शिफ्ट ऑपरेटर के रूप में माना, जो एक संकलन त्रुटि की ओर जाता है।

2) कुछ संकलक (उदाहरण के लिए विजुअल स्टूडियो 6.0) में एक बग था, जिसमें इस तथ्य को समाहित किया गया था कि टेम्पलेट पैरामीटर के रूप में शून्य प्रकार का उपयोग करना असंभव था। इन उद्देश्यों के लिए, एक अलग void_type प्रकार शून्य प्रकार को बदलने के लिए ऊपर के मार्ग में पेश किया जाता है, जहां डिफ़ॉल्ट टेम्पलेट पैरामीटर मान की आवश्यकता होती है।

3) बहुत पुराने कंपाइलर (उदाहरण के लिए बोरलैंड सी ++ बिल्डर) में एक कुटिल रूप से लागू प्रकार का बूल था , जो कुछ स्थितियों में "अचानक" इंट में बदल गया ( सच -> 1, गलत -> 0), साथ ही प्रकार के निरंतर स्थिर चर बूल (और केवल उन्हें नहीं), यदि वे टेम्पलेट कक्षाओं में निहित थे। इस सब गड़बड़ के कारण, परिणामस्वरूप, my_template_type :: static_bool_value == झूठी की शैली में पूरी तरह से हानिरहित तुलना के लिए , कंपाइलर आसानी से एक करामाती जारी कर सकता है जो 'अपरिभाषित प्रकार' को int (0) या ऐसा कुछ नहीं डाल सकता है। इसलिए, तुलना के लिए मूल्यों के प्रकार को स्पष्ट रूप से इंगित करने के लिए हमेशा प्रयास करना आवश्यक है, जिससे कंपाइलर को यह निर्धारित करने में मदद मिलती है कि वह किस प्रकार का व्यवहार कर रहा है।

कांस्टेबल और वाष्पशील मूल्यों के साथ अधिक काम जोड़ें। सबसे पहले, trivially कार्यान्वित किया गया remove_ ... जहां हम केवल कुछ प्रकार के संशोधक के लिए टेम्पलेट को विशेषज्ञ करते हैं - यदि प्रकार एक संशोधक के साथ आता है, तो संकलक को सभी विशिष्टताओं पर ध्यान देना चाहिए ( पिछले अध्याय से SFINAE सिद्धांत को याद रखें), सबसे उपयुक्त एक का चयन करें (वांछित संशोधक के स्पष्ट संकेत के साथ) :

 template<class _Tp> struct is_function; template<class _Tp> struct remove_const { // remove top level const qualifier typedef _Tp type; }; template<class _Tp> struct remove_const<const _Tp> { // remove top level const qualifier typedef _Tp type; }; template<class _Tp> struct remove_const<const volatile _Tp> { // remove top level const qualifier typedef volatile _Tp type; }; // remove_volatile template<class _Tp> struct remove_volatile { // remove top level volatile qualifier typedef _Tp type; }; template<class _Tp> struct remove_volatile<volatile _Tp> { // remove top level volatile qualifier typedef _Tp type; }; // remove_cv template<class _Tp> struct remove_cv { // remove top level const and volatile qualifiers typedef typename remove_const<typename remove_volatile<_Tp>::type>::type type; }; 

और फिर add_ पैटर्न ... जहां सब कुछ थोड़ा अधिक जटिल है एहसास:

 namespace detail { template<class _Tp, bool _IsFunction> struct _add_const_helper { typedef _Tp const type; }; template<class _Tp> struct _add_const_helper<_Tp, true> { typedef _Tp type; }; template<class _Tp, bool _IsFunction> struct _add_volatile_helper { typedef _Tp volatile type; }; template<class _Tp> struct _add_volatile_helper<_Tp, true> { typedef _Tp type; }; template<class _Tp, bool _IsFunction> struct _add_cv_helper { typedef _Tp const volatile type; }; template<class _Tp> struct _add_cv_helper<_Tp, true> { typedef _Tp type; }; } // add_const template<class _Tp> struct add_const: public detail::_add_const_helper<_Tp, is_function<_Tp>::value> { }; template<class _Tp> struct add_const<_Tp&> { typedef _Tp & type; }; // add_volatile template<class _Tp> struct add_volatile : public detail::_add_volatile_helper<_Tp, is_function<_Tp>::value> { }; template<class _Tp> struct add_volatile<_Tp&> { typedef _Tp & type; }; // add_cv template<class _Tp> struct add_cv : public detail::_add_cv_helper<_Tp, is_function<_Tp>::value> { }; template<class _Tp> struct add_cv<_Tp&> { typedef _Tp & type; }; 

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

चौथे अध्याय के पहले भाग का अंत। दूसरे भाग में मैं इस बारे में बात करूंगा कि कंपाइलर को कितना कठिन टेम्प्लेट प्रोग्रामिंग दी जाती है, और इसमें अधिक कूल टेम्प्लेट जादू भी होगा। आह, और अभी तक - क्यों लंबे समय तक अभिन्न निरंतर नहीं है, इस दिन के लिए कुछ संकलक के अनुसार।

आपका ध्यान के लिए धन्यवाद।