तर्कों की संख्या परिवर्तनशील टेम्पलेट, या एक मामूली जोड़ी क्या छुपाती है

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

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

... और यहाँ, जैसा कि वे कहते हैं, अधिक विस्तार से। हम जोड़ी निर्माता को कैसे कॉल कर सकते हैं और उसके दो सेट पास कर सकते हैं, ताकि यह समझ में आ जाए कि किस कंस्ट्रक्टर को कौन से तर्क देने हैं? सदस्यों या एक पूरी जोड़ी की नकल करने या आगे बढ़ने से जुड़े सामान्य कंस्ट्रक्टरों में, हम इसे देखते हैं:

template< class... Args1, class... Args2 > pair( std::piecewise_construct_t, std::tuple<Args1...> first_args, std::tuple<Args2...> second_args ); 

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

ठीक है, समस्या को सफलतापूर्वक हल किया जा रहा है: टुपल्स पहले और दूसरे कंस्ट्रक्टर के लिए तर्कों के "पैकेज" के रूप में कार्य करते हैं। इस स्तर पर, एक प्रोग्रामर जो नए मानक से परिचित हो जाता है, के पास एक प्रश्न हो सकता है: "वैसे, टुपल्स से डेटा कैसे अनपैक किए जाते हैं?" प्रलेखन हमें एक ही रास्ता देता है: प्राप्त फ़ंक्शन, जो टेम्पलेट पैरामीटर के रूप में ट्यूपल में तत्व के सूचकांक को इंगित करता है।

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

चलो मुख्य एक से शुरू करते हैं: आइए मौजूदा सूची में एक नया सूचकांक जोड़ें। जाहिर है, यदि नंबर 0 से शुरू होता है, तो नया सूचकांक इनपुट सूची के आकार के बराबर होगा। हमें एक ऐसी संरचना की आवश्यकता है जिसे हम सूचकांकों की सूची के साथ मानकीकृत करें:

 template<size_t ... Indices> struct PackIndices { //     Indices  ,  sizeof ... (Indices) }; 

परिणाम, जो संकलन समय के पूर्णांक स्थिरांक की एक सूची है और उसी समय, टेम्पलेट तर्क, अपने दम पर संग्रहीत नहीं किए जा सकते हैं, लेकिन आप इन तर्कों द्वारा टाइप किए गए प्रकार को संग्रहीत कर सकते हैं। और हमारे पास पहले से ही इस प्रकार की भूमिका के लिए एक उपयुक्त उम्मीदवार है:

 template<size_t ... Indices> struct PackIndices { typedef PackIndices<Indices... , sizeof ... (Indices)> next; }; 

अब चलो एक पुनरावर्ती जनरेटर बनाते हैं जो लंबाई एन के अनुक्रमित की एक सूची बनाता है । यह लंबाई एन -1 की सूची में अंतिम इंडेक्स को जोड़कर किया जाता है:

 template<size_t N> struct CreatePackIndices { typedef typename CreatePackIndices<N-1>::type::next type; }; 

... और पुनरावृत्ति को रोकें:

 template<> struct CreatePackIndices<0> { typedef PackIndices<> type; }; 

सूचकांकों की सूची बनाने का एक तरीका मिल गया है, हम निर्माण मापदंडों में टपल को खोल देंगे। सरलता के लिए, हम पहले केवल एक वस्तु का निर्माण करने पर विचार करते हैं, पहले ।

आर्गन्स टपल और इंडेक्स इंडेक्स सूची का उपयोग करते हुए, अनबॉक्सिंग को मूल रूप से इस तरह दिखना चाहिए:

 first(std::get<Indices>(args)...) 

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

 template<typename T> class pair { // ,   template<typename ... ArgTypes, size_t ... Indices> pair(std::tuple<ArgTypes...>& first_args, PackIndices<Indices...>): first(std::get<Indices>(first_args)...) {} public: // ,   template<typename ... ArgTypes> pair(std::piecewise_construct_t, const std::tuple<ArgTypes...>& first_args): pair(first_args, typename CreatePackIndices<sizeof ... (ArgTypes)>::type()) {} private: T first; }; 

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

 template<typename ... ArgTypes, size_t ... Indices> pair(std::tuple<ArgTypes...>& first_args, PackIndices<Indices...>): first(std::forward<ArgTypes>(std::get<Indices>(first_args))...) {} 

निर्माण पैरामीटर में make_tuple के मानों से सभी तरह से जाने के बाद, दोनों पैरों पर जोड़ी रखें :


बेशक, यह तकनीक न केवल एक अस्थायी साइकिल जोड़ी बनाने के लिए उपयोगी है। तो, स्टैक्ड वर्चुअल मशीनों से निपटने वाला एक प्रोग्रामर संभवतः कार्यों के लिए रैपर के साथ दिमाग में आएगा। निस्संदेह, अन्य क्षेत्रों में आवेदन होंगे।