इतिहास में अपना नाम हमेशा के लिए कैसे लिखें? चांद पर जाने वाली पहली उड़ान? एक विदेशी दिमाग से मिलने वाला पहला? हमारे पास एक सरल तरीका है - आप खुद को C ++ भाषा मानक में फिट कर सकते हैं।

सी ++ रेंज के लेखक एरिक निबलर एक अच्छा उदाहरण प्रदान करते हैं। “यह याद रखो। 19 फरवरी, 2019 वह दिन है, जब शब्द "nibloid" पहली बार WG21 की बैठक में बोला गया था, उन्होंने ट्विटर पर लिखा था।

दरअसल, अगर आप CppReference में , cpp / algorithm / rangescpp / एल्गोरिथ्म / पर्वतमाला अनुभाग में जाते हैं , तो आपको वहां कई संदर्भ मिलेंगे (niebloid)। इसके लिए, एक अलग dsc_niebloid विकी टेम्प्लेट भी बनाया गया है।

दुर्भाग्य से, मुझे इस विषय पर कोई आधिकारिक पूर्ण लेख नहीं मिला और मैंने खुद लिखने का फैसला किया। यह वास्तु अंतरिक्ष यात्रियों के रसातल में एक छोटी लेकिन आकर्षक यात्रा है, जिसमें हम ADL पागलपन के रसातल में डुबकी लगा सकते हैं और nibloids से परिचित हो सकते हैं।

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

लुक

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

उदाहरण के लिए, C ++ में एक नाम खोज की अवधारणा है या, दूसरे शब्दों में, एक लुकअप: जब किसी प्रोग्राम में कोई नाम मिलता है, तो वह संकलन के दौरान इसकी घोषणा के साथ संकलित करता है।

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

ADL

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

यह कैसा दिखना चाहिए?

 #include <iostream> int main() { //  . //   , operator<<    ,  ADL , //    std    std::operator<<(std::ostream&, const char*) std::cout << "Test\n"; //    .      -     . operator<<(std::cout, "Test\n"); // same, using function call notation //    : // Error: 'endl' is not declared in this namespace. //      endl(),  ADL  . std::cout << endl; //  . //    ,       ADL. //     std,   endl      std. endl(std::cout); //    : // Error: 'endl' is not declared in this namespace. //  ,  - (endl) -     . (endl)(std::cout); } 

ADL के साथ नरक में उतरो

यह सरल प्रतीत होगा। या नहीं? पहले, तर्क के प्रकार के आधार पर, एडीएल नौ अलग-अलग तरीकों से काम करता है , झाड़ू के साथ मारने के लिए।

दूसरे, विशुद्ध रूप से व्यावहारिक, कल्पना करें कि हमारे पास किसी प्रकार का स्वैप कार्य है। यह पता चला है कि std::swap(obj1,obj2); और using std::swap; swap(obj1, obj2); using std::swap; swap(obj1, obj2); पूरी तरह से अलग तरह से व्यवहार कर सकते हैं। यदि ADL सक्षम है, तो कई अलग-अलग स्वैप से, आपको जिस चीज़ की आवश्यकता है, वह पहले से ही तर्कों के नाम स्थान के आधार पर चुनी गई है! इस दृष्टिकोण के आधार पर, इस मुहावरे को सकारात्मक और नकारात्मक उदाहरण दोनों माना जा सकता है :-)

यदि आपको लगता है कि यह पर्याप्त नहीं है, तो आप हैट के ओवन में जलाऊ लकड़ी को गिरा सकते हैं। यह हाल ही में आर्थर ओ'डायर द्वारा लिखा गया था। मुझे आशा है कि वह अपने उदाहरण का उपयोग करने के लिए मुझे दंड नहीं देंगे।

कल्पना कीजिए कि आपके पास इस तरह का एक कार्यक्रम है:

 #include <stdio.h> namespace A { struct A {}; void call(void (*f)()) { f(); } } void f() { puts("Hello world"); } int main() { call(f); } 

बेशक, यह एक त्रुटि के साथ संकलित नहीं है:

 error: use of undeclared identifier 'call'; did you mean 'A::call'? call(f); ^~~~ A::call 

लेकिन अगर आप फ़ंक्शन f का पूरी तरह से अप्रयुक्त अधिभार जोड़ते हैं, तो सब कुछ काम करेगा!

 #include <stdio.h> namespace A { struct A {}; void call(void (*f)()) { f(); } } void f() { puts("Hello world"); } void f(A::A); // UNUSED int main() { call(f); } 

विजुअल स्टूडियो पर यह अभी भी टूट जाएगा, लेकिन यह उसका भाग्य है, काम नहीं कर रहा है।

यह कैसे हुआ? आइए मानक में तब्दील करें (अनुवाद के बिना, क्योंकि ऐसा अनुवाद buzzwords का असाधारण रूप से राक्षसी मिषम होगा):

यदि तर्क अतिभारित फ़ंक्शन और / या फ़ंक्शन टेम्प्लेट के सेट का नाम या पता है, तो इसकी संबद्ध इकाइयाँ और नामस्थान सेट के प्रत्येक सदस्य के साथ जुड़े लोगों के संघ हैं, अर्थात्, इसके पैरामीटर से जुड़ी संस्थाएँ और नामस्थान। प्रकार और वापसी प्रकार। [...] इसके अतिरिक्त, यदि ओवरलोड कार्यों के पूर्वोक्त सेट को एक टेम्पलेट-आईडी के साथ नामित किया गया है, तो इसके संबंधित निकाय और नामस्थान में इसके प्रकार के टेम्पलेट-तर्क और इसके टेम्पलेट टेम्पलेट-तर्क भी शामिल हैं।

अब एक कोड इस तरह लें:

 #include <stdio.h> namespace B { struct B {}; void call(void (*f)()) { f(); } } template<class T> void f() { puts("Hello world"); } int main() { call(f<B::B>); } 

दोनों मामलों में, ऐसे तर्क प्राप्त किए जाते हैं जिनका कोई प्रकार नहीं है। f और f<B::B> ओवरलोडेड फ़ंक्शंस के सेट के नाम हैं (ऊपर की परिभाषा से), और इस तरह के सेट का कोई प्रकार नहीं है। एक फ़ंक्शन में एक अधिभार को ढहाने के लिए, आपको यह समझने की आवश्यकता है कि सबसे अच्छा call अधिभार के लिए किस प्रकार का फ़ंक्शन पॉइंटर सबसे उपयुक्त है। तो, आपको call लिए उम्मीदवारों का एक सेट एकत्र करने की आवश्यकता है, जिसका अर्थ है लुकअप call चलाना। और इसके लिए ADL शुरू होगा!

लेकिन आमतौर पर ADL के लिए हमें तर्कों के प्रकारों को जानना चाहिए! और यहां क्लैंग, आईसीसी और MSVC गलती से टूट जाता है (लेकिन जीसीसी नहीं करता है):

 [build] ..\..\main.cpp(15,5): error: use of undeclared identifier 'call'; did you mean 'B::call'? [build] call(f<B::B>); [build] ^~~~ [build] B::call [build] ..\..\main.cpp(4,10): note: 'B::call' declared here [build] void call(void (*f)()) { [build] ^ 

यहां तक ​​कि एडीएल के साथ संकलक के रचनाकारों का थोड़ा तनावपूर्ण संबंध है।

अच्छा, क्या ADL अभी भी एक अच्छा विचार है? एक ओर, हमें विनम्र तरीके से इस तरह के स्लाव कोड लिखने की आवश्यकता नहीं है:

 std::cout << "Hello, World!" << std::endl; std::operator<<(std::operator<<(std::cout, "Hello, World!"), "\n"); 

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

रंग और अवधारणाएँ

यदि आप निबलर रेंजर्स लाइब्रेरी का विवरण खोलते हैं, तो निबोलिड्स के उल्लेख से पहले भी, आप कई अन्य मार्करों (अवधारणा) को ठोकर मारेंगे। यह पहले से ही एक सुंदर सामान है, लेकिन सिर्फ मामले में (बच्चों और जावेदों के लिए) मैं आपको याद दिलाता हूं कि यह क्या है ।

कॉन्सेप्ट को बाधाओं का नाम सेट कहा जाता है जो सबसे अच्छे फ़ंक्शन ओवरलोड और सबसे उपयुक्त टेम्पलेट विशेषज्ञताओं का चयन करने के लिए टेम्पलेट तर्कों पर लागू होते हैं।

 template <typename T> concept bool HasStringFunc = requires(T a) { { to_string(a) } -> string; }; void print(HasStringFunc a) { cout << to_string(a) << endl; } 

यहां हमने एक प्रतिबंध लगाया है कि तर्क में एक to_string फ़ंक्शन होना चाहिए जो एक स्ट्रिंग लौटाता है। यदि हम print भीतर कुछ गेम डालने की कोशिश करते हैं जो प्रतिबंधों के तहत नहीं आते हैं, तो ऐसे कोड बस संकलन नहीं करेंगे।

यह कोड को बहुत सरल करता है। उदाहरण के लिए, देखें कि निबलर ने रेंज-वी 3 में छंटाई कैसे की, जो सी ++ 11/14/17 में काम करता है। इस तरह एक अद्भुत कोड है:

 #define CONCEPT_PP_CAT_(X, Y) X ## Y #define CONCEPT_PP_CAT(X, Y) CONCEPT_PP_CAT_(X, Y) /// \addtogroup group-concepts /// @{ #define CONCEPT_REQUIRES_(...) \ int CONCEPT_PP_CAT(_concept_requires_, __LINE__) = 42, \ typename std::enable_if< \ (CONCEPT_PP_CAT(_concept_requires_, __LINE__) == 43) || (__VA_ARGS__), \ int \ >::type = 0 \ /**/ 

ताकि बाद में आप ऐसा कर सकें:

 struct Sortable_ { template<typename Rng, typename C = ordered_less, typename P = ident, typename I = iterator_t<Rng>> auto requires_() -> decltype( concepts::valid_expr( concepts::model_of<concepts::ForwardRange, Rng>(), concepts::is_true(ranges::Sortable<I, C, P>()) )); }; using Sortable = concepts::models<Sortable_, Rng, C, P>; template<typename Rng, typename C = ordered_less, typename P = ident, CONCEPT_REQUIRES_(!Sortable<Rng, C, P>())> void operator()(Rng &&, C && = C{}, P && = P{}) const { ... 

मुझे आशा है कि आप पहले से ही यह सब देखना चाहते थे और बस एक ताजा संकलक में तैयार अवधारणाओं का उपयोग करें।

अनुकूलन अंक

अगली दिलचस्प चीज जो मानक में पाई जा सकती है वह है custom.point.object । वे निबलर रेंज्स लाइब्रेरी में सक्रिय रूप से उपयोग किए जाते हैं।

अनुकूलन बिंदु मानक पुस्तकालय द्वारा उपयोग किया जाने वाला एक फ़ंक्शन है ताकि इसे उपयोगकर्ता के नामस्थान में उपयोगकर्ता प्रकारों के लिए अधिभारित किया जा सके, और ये अधिभार ADL का उपयोग करके पाया जा सकता है।

अनुकूलन अंक cust में निम्नलिखित वास्तु सिद्धांतों के साथ डिज़ाइन किए गए cust ( cust कुछ काल्पनिक अनुकूलन बिंदु का नाम है):

• cust कॉल करने वाला कोड या तो योग्य फॉर्म std::cust(a) या अयोग्य में लिखा गया है: using std::cust; cust(a); using std::cust; cust(a); । दोनों प्रविष्टियों को अनिवार्य रूप से व्यवहार करना चाहिए। विशेष रूप से, उन्हें तर्कों से जुड़े नामस्थान में कोई भी उपयोगकर्ता अधिभार ढूंढना होगा।
• कोड जो एक std::cust; cust(a); के रूप में cust का उपयोग करता cust std::cust; cust(a); std::cust; cust(a); std::cust पर लगाए गए प्रतिबंधों को दरकिनार करने में सक्षम नहीं होना चाहिए।
• कस्टम बिंदु कॉल किसी भी काफी आधुनिक संकलक पर कुशलतापूर्वक और बेहतर तरीके से काम करना चाहिए।
• निर्णय में एकल परिभाषा नियम (ODR) के किसी भी नए उल्लंघन का निर्माण नहीं किया जाना चाहिए।

यह समझने के लिए कि यह क्या है, आप N4381 पर एक नज़र डाल सकते हैं । पहली नज़र में, वे begin , swap , data और इसी तरह के अपने संस्करणों को लिखने के लिए एक तरह से दिखते हैं, और मानक पुस्तकालय एडीएल का उपयोग करके उन्हें चुनता है।

सवाल यह है कि यह पुरानी प्रथा से अलग कैसे है, जब उपयोगकर्ता अपने स्वयं के प्रकार और नाम स्थान के लिए कुछ के लिए एक अधिभार लिखता है? और वे वस्तुएं भी क्यों हैं?

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

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

अनुकूलन बिंदुओं के लिए वर्तमान दृष्टिकोण में कुछ समस्याएं हैं। सबसे पहले, सब कुछ तोड़ना बहुत आसान है। इस कोड की कल्पना करें:

 template<class T> void f(T& t1, T& t2) { using std::swap; swap(t1, t2); } 

अगर हम गलती से std::swap(t1, t2) लिए एक योग्य कॉल करते हैं std::swap(t1, t2) तो हमारे swap का अपना संस्करण कभी भी शुरू नहीं होगा, चाहे हम वहां कोई भी चीज डाल दें। लेकिन इससे भी महत्वपूर्ण बात यह है कि इस तरह के कस्टम फंक्शन इम्प्लीमेंटेशन के लिए सेंट्रली सेंसेशन चेक करने का कोई तरीका नहीं है। N4381 में वे लिखते हैं:

"कल्पना कीजिए कि किसी दिन, std::begin को आवश्यकता होगी कि इसके तर्क को एक Range अवधारणा के रूप में तैयार किया जाए। इस तरह के प्रतिबंध को जोड़ने से कोड का उपयोग करके मुहावरे पर कोड पर कोई प्रभाव नहीं पड़ेगा std::begin start:

 using std::begin; begin(a); 

आखिरकार, यदि begin कॉल उपयोगकर्ता द्वारा बनाए गए ओवरलोड संस्करण के लिए भेज दी जाती है, तो std::begin पर प्रतिबंध केवल अनदेखा कर दिया जाता है। ”

प्रोपोज़ल में वर्णित समाधान दोनों समस्याओं को हल करता है, इसके लिए हम std::begin इस सट्टा कार्यान्वयन से दृष्टिकोण का उपयोग करते हैं std::begin start (आप Godbolt को देख सकते हैं):

 #include <utility> namespace my_std { namespace detail { struct begin_fn { /*   ,         begin(arg)  arg.begin().  -   . */ template <class T> auto operator()(T&& arg) const { return impl(arg, 1L); } template <class T> auto impl(T&& arg, int) const requires requires { begin(std::declval<T>()); } { return begin(arg); } // ADL template <class T> auto impl(T&& arg, long) const requires requires { std::declval<T>().begin(); } { return arg.begin(); } // ... }; } //        inline constexpr detail::begin_fn begin{}; } 

कुछ my_std::begin(someObject) एक योग्य कॉल हमेशा my_std::detail::begin_fn - और इससे अच्छी होती है। एक अयोग्य कॉल क्या होता है? आइए फिर से पढ़ें हमारा पेपर:

“मामले में जब my_std::begin की उपस्थिति के तुरंत बाद योग्यता के बिना बुलाया जाता है my_std::begin गुंजाइश के अंदर my_std::begin , स्थिति कुछ हद तक बदल जाती है। लुकअप के पहले चरण में, नाम की begin वैश्विक ऑब्जेक्ट my_std::begin से begin । क्योंकि लुकअप में ऑब्जेक्ट मिला, फ़ंक्शन नहीं, लुकअप के दूसरे चरण का प्रदर्शन नहीं किया गया है। दूसरे शब्दों में, अगर my_std::begin एक ऑब्जेक्ट है, तो निर्माण का उपयोग my_std::detail::begin_fn begin; begin(a); my_std::detail::begin_fn begin; begin(a); बस std::begin(a); बराबर std::begin(a); "और जैसा कि हमने देखा है, यह कस्टम ADL लॉन्च करता है।"

यही कारण है कि एडीएल उपयोगकर्ता द्वारा प्रदान किए गए फ़ंक्शन को कॉल करने से पहले अवधारणा सत्यापन को std में एक फ़ंक्शन ऑब्जेक्ट में किया जा सकता है। इस व्यवहार को चकरा देने का कोई तरीका नहीं है।

अनुकूलन अंक कैसे अनुकूलित करते हैं?

वास्तव में, "अनुकूलन बिंदु वस्तु" (CPO) एक अच्छा नाम नहीं है। नाम से यह स्पष्ट नहीं है कि वे कैसे विस्तार करते हैं, क्या तंत्र हुड के नीचे हैं, वे कौन से कार्य पसंद करते हैं ...

जो हमें "nibloid" शब्द की ओर ले जाता है। एक nibloid एक CPO है जो फ़ंक्शन X को कॉल करता है यदि इसे कक्षा में परिभाषित किया जाता है, अन्यथा यह फ़ंक्शन X को कॉल करता है यदि कोई उपयुक्त फ़्री फ़ंक्शन है, अन्यथा यह फ़ंक्शन X के कुछ कमबैक को निष्पादित करने का प्रयास करता है।

तो उदाहरण के लिए, निबोलिड ranges::swap जब ranges::swap को बुलाती है तो ranges::swap ranges::swap(a, b) सबसे पहले a.swap(b) को कॉल करने का प्रयास करेगा। यदि ऐसी कोई विधि नहीं है, तो यह ADL का उपयोग करके swap(a, b) को कॉल करने का प्रयास करेगा। यदि यह काम नहीं करता है, तो auto tmp = std::move(a); a = std::move(b); b = std::move(tmp) आज़माएँ auto tmp = std::move(a); a = std::move(b); b = std::move(tmp) auto tmp = std::move(a); a = std::move(b); b = std::move(tmp) auto tmp = std::move(a); a = std::move(b); b = std::move(tmp) ।

परिणाम

जैसा कि मैट ने ट्विटर पर मजाक में कहा था, डेव ने एक बार नियमित कार्यों की तरह ही एडीएल के साथ कार्यात्मक वस्तुओं को "काम" करने का सुझाव दिया था, जो स्थिरता के कारणों के लिए है। विडंबना यह है कि एडीएल को निष्क्रिय करने और उसके लिए अदृश्य होने की उनकी क्षमता अब उनके मुख्य लाभ बन गए हैं।

यह पूरा लेख इसके लिए एक तैयारी थी।

" मैं बस सब कुछ समझ गया, बस इतना ही। क्या आप सुनेंगे ?

क्या आपने कभी कुछ देखा है, और यह पागल लग रहा था, और फिर एक अलग रोशनी में
पागल चीजें उन्हें सामान्य देखकर?

डरो मत। डरो मत। मुझे दिल से बहुत अच्छा लग रहा है। सब ठीक हो जाएगा। मैंने कई सालों से इतना अच्छा महसूस नहीं किया है। सब ठीक हो जाएगा।

विज्ञापन का मिनट। इस सप्ताह पहले से ही, 19-20 अप्रैल, सी ++ रूस 2019 आयोजित किया जाएगा - एक सम्मेलन दोनों भाषाओं में कट्टर प्रस्तुतियों से भरा हुआ है और मल्टीथ्रेडिंग और प्रदर्शन जैसे व्यावहारिक मुद्दों पर। वैसे, सम्मेलन को सी ++ स्टैंडर्ड लाइब्रेरी: ए ट्यूटोरियल एंड रेफरेंस के लेखक, निकोलै जोसुटिस ने लेख में उल्लेख किया है। आप कार्यक्रम से खुद को परिचित कर सकते हैं और आधिकारिक वेबसाइट पर टिकट खरीद सकते हैं। बहुत कम समय बचा है, यह आखिरी मौका है।