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

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

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

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

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

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

तो, चलो जारी रखें।

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

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

अध्याय 3. सही nullptr कार्यान्वयन ढूँढना

गैर-मानक संकलक मैक्रोज़ और "अद्भुत" खोजों के साथ पूरे महाकाव्य के बाद, उन्होंने प्रस्तुत किया, मैं अंत में नल्ट्रप्र जोड़ सकता हूं और यह मेरी आत्मा को गर्म कर सकता है। अंत में, आप इन सभी तुलनाओं को 0 या यहां तक ​​कि NULL से छुटकारा दिला सकते हैं।

अधिकांश प्रोग्रामर nullptr को लागू करते हैं

#define nullptr 0 

और यह इस अध्याय को समाप्त कर सकता था। यदि आप अपने आप को अशक्त करना चाहते हैं, तो बस इस तरह के एक परिभाषित के साथ 0 को बदलें, क्योंकि संक्षेप में यह सब सही संचालन के लिए आवश्यक है।

वास्तव में चेक लिखना न भूलें, अन्यथा अचानक किसी और को इस परिभाषा के साथ मिल जाएगा:

 #ifndef nullptr #define nullptr 0 #else #error "nullptr defined already" #endif 

पूर्वप्रक्रमक निर्देश #error संकलन करते समय मानव-पठनीय पाठ के साथ एक त्रुटि उत्पन्न करेगा, और, हाँ, यह एक मानक निर्देश है, जिसका उपयोग दुर्लभ है, लेकिन पाया जा सकता है।

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

 class nullptr_t_as_class_impl { public: nullptr_t_as_class_impl() { } nullptr_t_as_class_impl(int) { } // Make nullptr convertible to any pointer type. template<typename T> operator T*() const { return 0; } // Make nullptr convertible to any member pointer type. template<typename C, typename T> operator TC::*() { return 0; } bool operator==(nullptr_t_as_class_impl) const { return true; } bool operator!=(nullptr_t_as_class_impl) const { return false; } private: // Do not allow taking the address of nullptr. void operator&(); void *_padding; }; typedef nullptr_t_as_class_impl nullptr_t; #define nullptr nullptr_t(0) 

किसी भी पॉइंटर में इस क्लास का रूपांतरण टाइप ऑपरेटर के टेम्प्लेट ऑपरेटर के कारण होता है, जिसे अगर nullptr के साथ तुलना की जाती है तो इसे कहा जाता है। यही है, अभिव्यक्ति चार * my_pointer; if (my_pointer == nullptr) को वास्तव में if (my_pointer == nullptr.operator char * ()) में बदल दिया जाएगा , जो सूचक की तुलना 0. करता है। दूसरे प्रकार के ऑपरेटर को बिंदु से वर्ग के सदस्यों तक बिंदु में बदलने के लिए आवश्यक है। और यहां बोरलैंड सी ++ बिल्डर 6.0 "खुद को प्रतिष्ठित", जिन्होंने अप्रत्याशित रूप से फैसला किया कि ये दोनों ऑपरेटर समान हैं और आसानी से एक वर्ग के सदस्य और एक दूसरे के साथ साधारण पॉइंटर्स की तुलना कर सकते हैं, इसलिए हर बार अनिश्चितता होती है जब इस तरह के एक नल्टर की तुलना की जाती है सूचक (यह एक बग है, और शायद यह केवल इस संकलक के साथ नहीं है)। हम इस मामले के लिए एक अलग कार्यान्वयन लिख रहे हैं:

 class nullptr_t_as_class_impl1 { public: nullptr_t_as_class_impl1() { } nullptr_t_as_class_impl1(int) { } // Make nullptr convertible to any pointer type. template<typename T> operator T*() const { return 0; } bool operator==(nullptr_t_as_class_impl1) const { return true; } bool operator!=(nullptr_t_as_class_impl1) const { return false; } private: // Do not allow taking the address of nullptr. void operator&(); void *_padding; }; typedef nullptr_t_as_class_impl1 nullptr_t; #define nullptr nullptr_t(0) 

इस nullptr दृश्य के फायदे यह हैं कि अब std :: nullptr_t के लिए एक अलग प्रकार है। नुकसान? Nullptr स्थिरांक संकलन के दौरान खो जाता है और टर्नरी ऑपरेटर के माध्यम से तुलना करता है, संकलक इसे हल नहीं कर सकता है।

 unsigned* case5 = argc > 2 ? (unsigned*)0 : nullptr; //  ,     ':'    STATIC_ASSERT(nullptr == nullptr && !(nullptr != nullptr), nullptr_should_be_equal_itself); //  , nullptr      

और मैं "और चेकर्स और जाना चाहता हूं।" इसका समाधान केवल एक के दिमाग में आता है: एनम । C ++ में गणना के सदस्यों का अपना अलग प्रकार होगा, और उन्हें बिना किसी समस्या के int में भी परिवर्तित किया जाएगा (और वास्तव में वे पूर्णांक स्थिरांक हैं)। एक एन्यूमरेशन सदस्य की यह संपत्ति हमारी मदद करेगी, क्योंकि बहुत "विशेष" 0 जो पॉइंटर्स के लिए nullptr के बजाय उपयोग किया जाता है, सबसे आम इंट है । मैंने इंटरनेट पर nullptr का ऐसा क्रियान्वयन नहीं देखा है, और शायद यह भी कुछ बुरा है, लेकिन मेरे पास ऐसा कोई विचार नहीं था। आइए एक कार्यान्वयन लिखें:

 #ifdef NULL #define STDEX_NULL NULL #else #define STDEX_NULL 0 #endif namespace ptrdiff_detail { using namespace std; } template<bool> struct nullptr_t_as_ulong_type { typedef unsigned long type; }; template<> struct nullptr_t_as_ulong_type<false> { typedef unsigned long type; }; template<bool> struct nullptr_t_as_ushort_type { typedef unsigned short type; }; template<> struct nullptr_t_as_ushort_type<false> { typedef nullptr_t_as_long_type<sizeof(unsigned long) == sizeof(void*)>::type type; }; template<bool> struct nullptr_t_as_uint_type { typedef unsigned int type; }; template<> struct nullptr_t_as_uint_type<false> { typedef nullptr_t_as_short_type<sizeof(unsigned short) == sizeof(void*)>::type type; }; typedef nullptr_t_as_uint_type<sizeof(unsigned int) == sizeof(void*)>::type nullptr_t_as_uint; enum nullptr_t_as_enum { _nullptr_val = ptrdiff_detail::ptrdiff_t(STDEX_NULL), _max_nullptr = nullptr_t_as_uint(1) << (CHAR_BIT * sizeof(void*) - 1) }; typedef nullptr_t_as_enum nullptr_t; #define nullptr nullptr_t(STDEX_NULL) 

जैसा कि आप यहाँ देख सकते हैं सदस्य nullptr = 0 के साथ enum nullptr_t की घोषणा करने की तुलना में थोड़ा अधिक कोड। पहले, NULL परिभाषाएँ नहीं हो सकती हैं। इसे मानक हेडर की एक ठोस सूची में परिभाषित किया जाना चाहिए, लेकिन जैसा कि अभ्यास ने दिखाया है, इस मैक्रो के लिए इसे सुरक्षित रूप से खेलना और जांचना बेहतर है। दूसरे, कार्यान्वयन-परिभाषित मानक के अनुसार सी ++ में एनम प्रतिनिधित्व, अर्थात्। एन्यूमरेशन प्रकार को किसी भी पूर्णांक प्रकारों से दर्शाया जा सकता है (प्रोविज़ो के साथ कि ये प्रकार इंट से अधिक नहीं हो सकते हैं, बशर्ते कि एनम मान इसमें फिट हो)। उदाहरण के लिए, यदि आप enum test {_1, _2} की घोषणा करते हैं , तो कंपाइलर आसानी से इसे संक्षिप्त रूप में प्रस्तुत कर सकता है , और फिर यह संभव है कि आकार ( परीक्षण ) ! = Sizeof (शून्य) । मानक का पालन करने के लिए नल्ट्रप्र कार्यान्वयन के लिए, आपको यह सुनिश्चित करने की आवश्यकता है कि कंपाइलर के आकार का प्रकार nullptr_t_as_enum पॉइंटर के आकार से मेल खाता है, अर्थात अनिवार्य रूप से बराबर आकार का (शून्य *) । ऐसा करने के लिए, nullptr_t_as ... टेम्प्लेट का उपयोग करते हुए, पूर्णांक प्रकार का चयन करें जो पॉइंटर के आकार के बराबर होगा, और फिर हमारे एन्यूमरेशन में तत्व का अधिकतम मान इस पूर्णांक प्रकार के अधिकतम मान पर सेट करें।

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

और एक अन्य विशेषता एनएलएम का असाइनमेंट एनम तत्व के मूल्य के रूप में है। कुछ संकलक एक चेतावनी देते हैं (और उनकी चिंता को समझा जा सकता है) इस तथ्य के बारे में कि NULL को "गैर-अनुक्रमणक" को सौंपा गया है। हम अपने स्थानीय ptrdiff_detail को मानक नाम स्थान लेते हैं , इसलिए शेष नामस्थान को अव्यवस्थित करने के लिए नहीं, और फिर संकलक को शांत करने के लिए, हम स्पष्ट रूप से NULL को std में परिवर्तित करते हैं :: ptrdiff -t - C ++ में एक और किसी प्रकार का अप्रयुक्त प्रकार, जो अंकगणितीय संक्रियाओं के परिणाम का प्रतिनिधित्व करने का कार्य करता है। (घटाव) संकेत के साथ और आमतौर पर प्रकार का एक उपनाम है std :: size_t ( std :: intptr_t C ++ 11 में)।

SFINAE

यहाँ, मेरी कहानी में पहली बार, हमें C ++ में ऐसी घटना का सामना करना पड़ रहा है क्योंकि प्रतिस्थापन विफलता एक त्रुटि नहीं है (SFINA) । संक्षेप में, इसका सार यह है कि जब संकलक “किसी विशेष कॉल के लिए उपयुक्त फ़ंक्शन ओवरलोड” से गुजरता है, तो उसे सभी की जांच करनी चाहिए, और पहली विफलता के बाद या पहले उपयुक्त अधिभार के बाद रुकना नहीं चाहिए। यहां से अस्पष्टता के बारे में उनका संदेश आता है , जब कहा जाता है कि फ़ंक्शन के दो अधिभार हैं जो संकलक के दृष्टिकोण से समान हैं, साथ ही साथ कंपाइलर की क्षमता विशिष्ट मापदंडों के लिए एक विशिष्ट कॉल के लिए सबसे सटीक उपयुक्त फ़ंक्शन अधिभार का चयन करने की क्षमता है। कंपाइलर की यह सुविधा आपको सभी टेम्पलेट "मैजिक" के शेर के हिस्से को करने की अनुमति देती है (वैसे hi std :: enable_if ), और यह बूस्ट और मेरी लाइब्रेरी दोनों का आधार भी है।

चूंकि, परिणामस्वरूप, हमारे पास कई nullptr कार्यान्वयन हैं , हम संकलन चरण में SFINAE का चयन "सर्वश्रेष्ठ" करते हैं। हम नीचे घोषित जांच कार्यों के आकार के माध्यम से जाँच के लिए "हाँ" और "नहीं" प्रकार घोषित करते हैं।

 namespace nullptr_detail { typedef char _yes_type; struct _no_type { char padding[8]; }; struct dummy_class {}; _yes_type _is_convertable_to_void_ptr_tester(void*); _no_type _is_convertable_to_void_ptr_tester(...); typedef void(nullptr_detail::dummy_class::*dummy_class_f)(int); typedef int (nullptr_detail::dummy_class::*dummy_class_f_const)(double&) const; _yes_type _is_convertable_to_member_function_ptr_tester(dummy_class_f); _no_type _is_convertable_to_member_function_ptr_tester(...); _yes_type _is_convertable_to_const_member_function_ptr_tester(dummy_class_f_const); _no_type _is_convertable_to_const_member_function_ptr_tester(...); template<class _Tp> _yes_type _is_convertable_to_ptr_tester(_Tp*); template<class> _no_type _is_convertable_to_ptr_tester(...); } 

यहां हम उसी सिद्धांत का उपयोग दूसरे अध्याय के रूप में करेंगे जिसमें काउंटरटॉप और इसकी परिभाषा के आकार के माध्यम से रिटर्न ऑफ वैल्यू (तत्वों का सार ) टेम्पलेट फ़ंक्शन COUNTOF_REQUIRES_ARRAY_ARGUMENT है ।

 template<class T> struct _is_convertable_to_void_ptr_impl { static const bool value = (sizeof(nullptr_detail::_is_convertable_to_void_ptr_tester((T) (STDEX_NULL))) == sizeof(nullptr_detail::_yes_type)); }; 

यहाँ क्या हो रहा है? सबसे पहले, कंपाइलर टाइप टी के तर्क के साथ _is_convertable_to_void_ptr_tester के ओवरलोड को " iterates " करता है और NULL का मान (एक भूमिका नहीं निभाता है, बस फुल टाइप- T होना चाहिए)। केवल दो अधिभार हैं - शून्य * प्रकार के साथ और चर तर्क सूची (...) के साथ । इन ओवरलोड में से प्रत्येक में एक तर्क को प्रतिस्थापित करते हुए, कंपाइलर पहले का चयन करेगा यदि प्रकार को पॉइंटर के लिए शून्य पर रखा गया है , और दूसरा यदि कलाकारों को प्रदर्शन नहीं किया जा सकता है। कंपाइलर द्वारा चयनित अधिभार के साथ, हम फ़ंक्शन द्वारा लौटाए गए मूल्य के आकार को निर्धारित करने के लिए आकार का उपयोग करते हैं, और चूंकि वे अलग-अलग होने की गारंटी देते हैं ( sizeof ) ( _no_type ) == 8 , sizeof ( _yes_type = = 1 ), हम उस अधिभार का आकार निर्धारित कर सकते हैं जो संकलक ने उठाया है और इसलिए परिवर्तित होता है। हमारा प्रकार शून्य में है या नहीं।

हम उसी प्रोग्रामिंग टेम्प्लेट को लागू करेंगे ताकि यह निर्धारित किया जा सके कि nullptr_t का प्रतिनिधित्व करने के लिए हमारी पसंद के प्रकार का कोई ऑब्जेक्ट किसी पॉइंटर में परिवर्तित किया गया है (अनिवार्य रूप से (T) ( STDEX_NULL ) nullptr के लिए भविष्य की परिभाषा है)।

 template<class T> struct _is_convertable_to_member_function_ptr_impl { static const bool value = (sizeof(nullptr_detail::_is_convertable_to_member_function_ptr_tester((T) (STDEX_NULL))) == sizeof(nullptr_detail::_yes_type)) && (sizeof(nullptr_detail::_is_convertable_to_const_member_function_ptr_tester((T) (STDEX_NULL))) == sizeof(nullptr_detail::_yes_type)); }; template<class NullPtrType, class T> struct _is_convertable_to_any_ptr_impl_helper { static const bool value = (sizeof(nullptr_detail::_is_convertable_to_ptr_tester<T>((NullPtrType) (STDEX_NULL))) == sizeof(nullptr_detail::_yes_type)); }; template<class T> struct _is_convertable_to_any_ptr_impl { static const bool value = _is_convertable_to_any_ptr_impl_helper<T, int>::value && _is_convertable_to_any_ptr_impl_helper<T, float>::value && _is_convertable_to_any_ptr_impl_helper<T, bool>::value && _is_convertable_to_any_ptr_impl_helper<T, const bool>::value && _is_convertable_to_any_ptr_impl_helper<T, volatile float>::value && _is_convertable_to_any_ptr_impl_helper<T, volatile const double>::value && _is_convertable_to_any_ptr_impl_helper<T, nullptr_detail::dummy_class>::value; }; template<class T> struct _is_convertable_to_ptr_impl { static const bool value = ( _is_convertable_to_void_ptr_impl<T>::value == bool(true) && _is_convertable_to_any_ptr_impl<T>::value == bool(true) && _is_convertable_to_member_function_ptr_impl<T>::value == bool(true) ); }; 

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

जैसा कि ऊपर उल्लेख किया गया है, कुछ (* khe-khe * ... Borland Builder 6.0 ... * khe *) कंपाइलर एक प्रकार और एक वर्ग के सदस्य के बीच संकेत में अंतर नहीं करते हैं, इसलिए हम इस मामले के लिए एक और सहायक चेक लिखेंगे ताकि हम कक्षा के माध्यम से nullptr_t के वांछित कार्यान्वयन का चयन कर सकें। अगर जरूरत हो

 struct _member_ptr_is_same_as_ptr { struct test {}; typedef void(test::*member_ptr_type)(void); static const bool value = _is_convertable_to_void_ptr_impl<member_ptr_type>::value; }; template<bool> struct _nullptr_t_as_class_chooser { typedef nullptr_detail::nullptr_t_as_class_impl type; }; template<> struct _nullptr_t_as_class_chooser<false> { typedef nullptr_detail::nullptr_t_as_class_impl1 type; }; 

और फिर यह केवल nullptr_t के विभिन्न कार्यान्वयनों की जांच करने और कंपाइलर के लिए उपयुक्त संकलक चुनने के लिए बनी हुई है।


सबसे पहले, हम एक वर्ग के रूप में nullptr_t का प्रतिनिधित्व करने की संभावना की जांच करते हैं, लेकिन जब से मुझे एक स्वतंत्र समाधान का एक सार्वभौमिक संकलक नहीं मिला, मुझे एक प्रकार की वस्तु नहीं मिली जो संकलन समय का एक निरंतरता हो सकती है (वैसे, मैं इस विषय पर सुझाव के लिए खुला हूं, क्योंकि यह संभावना है कि यह संभव है), यह विकल्प हमेशा जांचा जाता है ( _can_be_ct_constant हमेशा गलत होता है )। अगला, हम एनम के माध्यम से दृश्य के साथ संस्करण की जांच करने के लिए स्विच करते हैं। यदि यह अभी भी प्रस्तुत करना संभव नहीं था (कंपाइलर एनम के माध्यम से एक सूचक पेश नहीं कर सकता है या आकार किसी तरह गलत है), तो हम इसे पूर्णांक प्रकार (जिसका आकार सूचक के शून्य के बराबर होगा) के रूप में प्रतिनिधित्व करने का प्रयास करते हैं। खैर, यहां तक ​​कि अगर यह काम नहीं करता है, तो हम शून्य * के माध्यम से nullptr_t प्रकार के कार्यान्वयन का चयन करते हैं।

इस बिंदु पर, C ++ टेम्पलेट्स के साथ संयोजन में SFINAE की अधिकांश शक्ति का पता चला है, जिसके कारण संकलक-निर्भर मैक्रोज़ का सहारा लिए बिना आवश्यक कार्यान्वयन का चयन करना संभव है, और वास्तव में मैक्रोज़ के लिए (बढ़ावा के विपरीत जहां यह सब #ifdef #else # चेक के साथ crammed होगा। एंडिफ )।

यह केवल नामस्थान stdex में nullptr_t के लिए एक प्रकार का उपनाम और परिभाषित करने के लिए बना रहता है ( nullptr के लिए एक परिभाषित करता है (ताकि एक अन्य मानक आवश्यकता का पालन किया जा सके कि nullptr पता नहीं लिया जा सकता है, साथ ही साथ nullptr को एक संकलन समय स्थिर के रूप में)।

 namespace stdex { typedef detail::_nullptr_chooser::type nullptr_t; } #define nullptr (stdex::nullptr_t)(STDEX_NULL) 

तीसरे अध्याय का अंत। चौथे अध्याय में, मैं आखिरकार टाइप_टाइट्स पर पहुंच गया और विकास के दौरान संकलकों में कौन से कीड़े आए।

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