कक्षा टेम्पलेट तर्क कटौती

C ++ 17 मानक ने भाषा में एक नई सुविधा जोड़ी: क्लास टेम्पलेट तर्क कटौती (CTAD) । सी ++ में नई सुविधाओं के साथ, पारंपरिक रूप से अपने स्वयं के अंगों की शूटिंग के नए तरीके जोड़े। इस लेख में हम समझेंगे कि CTAD क्या है, इसका उपयोग किस लिए किया जाता है, यह जीवन को कैसे सरल बनाता है और इसके क्या नुकसान हैं।

दूर से शुरू करते हैं

याद रखें कि टेम्पलेट तर्क कटौती के बारे में क्या है और इसके लिए क्या है। यदि आप सी ++ टेम्पलेट्स के साथ पर्याप्त आत्मविश्वास महसूस करते हैं, तो आप इस अनुभाग को छोड़ सकते हैं और तुरंत अगले पर जा सकते हैं।

C ++ 17 से पहले, टेम्प्लेट मापदंडों का आउटपुट केवल फ़ंक्शन टेम्प्लेट पर लागू होता है। किसी फंक्शन टेम्प्लेट को इंस्टेंट करते समय, आप उन टेम्प्लेट तर्कों को स्पष्ट रूप से निर्दिष्ट नहीं कर सकते हैं, जिन्हें वास्तविक फ़ंक्शन तर्कों के प्रकार से अनुमान लगाया जा सकता है। कटौती करने के नियम काफी जटिल हैं, वे मानक [temp.deduct] में पूरे खंड 17.9.2 में शामिल हैं (इसके बाद मैं मानक के स्वतंत्र रूप से उपलब्ध संस्करण का संदर्भ देता हूं; भविष्य के संस्करणों में, अनुभाग क्रमांक बदल सकता है, इसलिए मैं निर्दिष्ट मेनेमोनिक कोड द्वारा खोज करने की सलाह देता हूं; वर्ग कोष्ठक)।

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

template <typename T> void func(T t) { // ... } int some_func(double d) { return static_cast<int>(d); } int main() { const int i = 123; func(i); // func<int> char arr[] = "Some text"; func(arr); // func<char *> func(some_func); // func<int (*)(double)> return 0; } 

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

 //  auto tup1 = std::tuple<int, char, double>(123, 'a', 40.0); //   auto tup2 = std::make_tuple(123, 'a', 40.0); 

C ++ 17 में नया

नए मानक में, फ़ंक्शन टेम्प्लेट के मापदंडों के साथ समानता से, क्लास टेम्प्लेट के पैरामीटर को तथाकथित कंस्ट्रक्शन के तर्कों से प्राप्त किया जाता है:

 std::pair pr(false, 45.67); // std::pair<bool, double> std::tuple tup(123, 'a', 40.0); // std::tuple<int, char, double> std::less l; // std::less<void>,     std::less<> l template <typename T> struct A { A(T,T); }; auto y = new A{1, 2}; //  A<int> auto lck = std::lock_guard(mtx); // std::lock_guard<std::mutex> std::copy_n(vi1, 3, std::back_insert_iterator(vi2)); //       template <typename T> struct F { F(T); } std::for_each(vi.begin(), vi.end(), Foo([&](int i) {...})); // F<lambda> 

तुरंत यह CTAD प्रतिबंधों का उल्लेख करने योग्य है जो C ++ 17 के समय पर लागू होते हैं (शायद ये प्रतिबंध मानक के भविष्य के संस्करणों में हटा दिए जाएंगे):

• CTAD टेम्पलेट एलियास के साथ काम नहीं करता है:

 template <typename X> using PairIntX = std::pair<int, X>; PairIntX p{1, true}; //   

• CTAD तर्कों के आंशिक उत्पादन की अनुमति नहीं देता (यह नियमित टेम्पलेट तर्क कटौती के लिए कैसे काम करता है):

 std::pair p{1, 5}; // OK std::pair<double> q{1, 5}; // ,   std::pair<double, int> r{1, 5}; // OK 

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

 template <typename T> struct MyVector { template <typename It> MyVector(It from, It to); }; std::vector<double> dv = {1.0, 3.0, 5.0, 7.0}; MyVector v2{dv.begin(), dv.end()}; //     T   It 

प्रकार यह सीधे टी से संबंधित नहीं है, हालांकि हम डेवलपर्स को जानते हैं कि इसे कैसे प्राप्त किया जाए। कंपाइलर को सीधे असंबंधित प्रकारों को आउटपुट करने का तरीका बताने के लिए, सी ++ 17 में एक नई भाषा का निर्माण दिखाई दिया - कटौती गाइड , जिसे हम अगले अनुभाग में चर्चा करेंगे।

समर्पण मार्गदर्शक

ऊपर के उदाहरण के लिए, कटौती गाइड इस तरह दिखेगा:

 template <typename It> MyVector(It, It) -> MyVector<typename std::iterator_traits<It>::value_type>; 

यहां हम कंपाइलर को बताते हैं कि एक कंस्ट्रक्टर के लिए एक ही प्रकार के दो मापदंडों के साथ, आप निर्माण std::iterator_traits<It>::value_type का उपयोग करके T का प्रकार निर्धारित कर सकते हैं। कृपया ध्यान दें कि कटौती गाइड वर्ग परिभाषा के बाहर हैं, यह आपको सी ++ मानक लाइब्रेरी से कक्षाओं सहित बाहरी कक्षाओं के व्यवहार को अनुकूलित करने की अनुमति देता है।

कटौती गाइडों के सिंटैक्स का एक औपचारिक विवरण C ++ मानक 17 में धारा 17.10 में दिया गया है [temp.deduct.nide] :

 [explicit] template-name (parameter-declaration-clause) -> simple-template-id; 

कटौती गाइड से पहले स्पष्ट कीवर्ड कॉपी-सूची-प्रारंभ के साथ इसका उपयोग करने से मना करता है :

 template <typename It> explicit MyVector(It, It) -> MyVector<typename std::iterator_traits<It>::value_type>; std::vector<double> dv = {1.0, 3.0, 5.0, 7.0}; MyVector v2{dv.begin(), dv.end()}; //  MyVector v3 = {dv.begin(), dv.end()}; //   

वैसे, कटौती मार्गदर्शिका का कोई खाका नहीं है:

 template<class T> struct S { S(T); }; S(char const*) -> S<std::string>; S s{"hello"}; // S<std::string> 

विस्तृत CTAD एल्गोरिथ्म

कक्षा टेम्पलेट के तर्कों को प्राप्त करने के लिए औपचारिक नियमों का वर्णन C ++ मानक 17 के खंड 16.3.1.8 [over.match.class.deduct] में विस्तार से किया गया है। आइए जानने की कोशिश करते हैं।

तो, हमारे पास एक टेम्पलेट प्रकार C है जिसके लिए CTAD लागू है। सी के लिए किस निर्माता और किस पैरामीटर से कॉल करना है, यह चुनने के लिए, निम्नलिखित नियमों के अनुसार बहुत सारे टेम्पलेट फ़ंक्शन बनाए जाते हैं:

• प्रत्येक सीआई कंस्ट्रक्टर के लिए, एक डमी फाई टेम्पलेट फ़ंक्शन उत्पन्न होता है। सीआई टेम्प्लेट पैरामीटर सी पैरामीटर हैं, इसके बाद सीआई टेम्प्लेट पैरामीटर (यदि कोई हो), जिसमें डिफ़ॉल्ट मान वाले पैरामीटर शामिल हैं। Fi फ़ंक्शन के पैरामीटर प्रकार, सीआई कंस्ट्रक्टर के पैरामीटर प्रकार के अनुरूप होते हैं। C टेम्पलेट पैरामीटर से मेल खाते तर्कों के साथ एक डमी फ़ंक्शन Fi टाइप C लौटाता है।

छद्म कोड:

 template <typename T, typename U> class C { public: template <typename V, typename W = A> C(V, W); }; //    template <typename T, typename U, typename V, typename W = A> C<T, U> Fi(V, W); 

• यदि टाइप C परिभाषित नहीं है, या कोई निर्माता निर्दिष्ट नहीं है, तो उपरोक्त नियम काल्पनिक कंस्ट्रक्टर C () पर लागू होते हैं।
• C © कंस्ट्रक्टर के लिए एक अतिरिक्त डमी फ़ंक्शन उत्पन्न होता है, वे इसके लिए एक विशेष नाम के साथ भी आए: प्रतिलिपि कटौती उम्मीदवार ।
• प्रत्येक कटौती गाइड के लिए , एक डमी फंक्शन Fi को टेम्प्लेट पैरामीटर और डिडक्शन गाइड तर्कों के साथ उत्पन्न किया जाता है और कटौती गाइड में -> के दाईं ओर टाइप करने के लिए इसी प्रकार का रिटर्न मान होता है (औपचारिक परिभाषा में इसे सरल-टेम्पलेट-आईडी कहा जाता है )।

छद्म कोड:

 template <typename T, typename V> C(T, V) -> C<typename DT<T>, typename DT<V>>; //    template <typename T, typename V> C<typename DT<T>, typename DT<V>> Fi(T,V); 

इसके अलावा, फाई डमी फ़ंक्शंस के परिणामी सेट के लिए, टेम्प्लेट पैरामीटर और ओवरलोड रिज़ॉल्यूशन आउटपुट के लिए सामान्य नियम एक अपवाद के साथ लागू होते हैं: जब डमी फंक्शन को इनिशियलाइज़ेशन सूची के साथ बुलाया जाता है, जिसमें एकल cv U के एकल पैरामीटर शामिल होते हैं, जहाँ U स्पेशलाइज़ेशन C या स्पेशलाइज़ेशन C से टाइप किया गया प्रकार होता है। (बस अगर मैं स्पष्ट करूं कि cv == const वाष्पशील ; इस तरह के रिकॉर्ड का अर्थ है U , const U , अस्थिर U और const वाष्पशील U का समान रूप से व्यवहार किया जाता है), वह नियम जो कंस्ट्रक्टर C(std::initializer_list<>) को प्राथमिकता देता C(std::initializer_list<>) सूची की जानकारी के लिए Lization को C ++ Standard 17 के खंड 16.3.1.7 [over.match.list] में पाया जा सकता है। एक उदाहरण:

 std::vector v1{1, 2}; // std::vector<int> std::vector v2{v1}; // std::vector<int>,   std::vector<std::vector<int>> 

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

नुकसान

CTAD का उपयोग वस्तुओं को इनिशियलाइज़ करने के लिए किया जाता है, और इनिशियलाइज़ेशन पारंपरिक रूप से C ++ भाषा का एक बहुत ही भ्रमित करने वाला हिस्सा है। C ++ 11 में वर्दी इनिशियलाइज़ेशन के साथ, आपके पैर से गोली मारने के तरीके केवल बढ़े हैं। अब आप निर्माता को गोल और घुंघराले ब्रैकेट के साथ किसी वस्तु के लिए कॉल कर सकते हैं। कई मामलों में, ये दोनों विकल्प समान काम करते हैं, लेकिन हमेशा नहीं:

 std::vector v1{8, 15}; // [8, 15] std::vector v2(8, 15); // [15, 15, … 15] (8 ) std::vector v3{8}; // [8] std::vector v4(8); //   

अब तक, सब कुछ काफी तार्किक प्रतीत होता है: v1 और v3 निर्माता को कॉल करता है जो std::initializer_list<int> लेता है, int मापदंडों से अनुमानित है; v4 को एक कंस्ट्रक्टर नहीं मिल सकता है जो टाइप इंट का केवल एक पैरामीटर लेता है। लेकिन ये अभी भी फूल हैं, सामने जामुन:

 std::vector v5{"hi", "world"}; // [“hi”, “world”] std::vector v6("hi", "world"); // ?? 

v5 , जैसा कि अपेक्षित था, std::vector<const char*> प्रकार का होगा std::vector<const char*> और दो तत्वों के साथ इनिशियलाइज़ किया जाता है, लेकिन अगली पंक्ति पूरी तरह से कुछ अलग करती है। एक वेक्टर के लिए, केवल एक कंस्ट्रक्टर होता है जो एक ही प्रकार के दो पैरामीटर लेता है:

 template< class InputIt > vector( InputIt first, InputIt last, const Allocator& alloc = Allocator() ); 

std::vector लिए कटौती गाइड के लिए धन्यवाद std::vector "हाय" और "दुनिया" को पुनरावृत्तियों के रूप में माना जाएगा, और "बीच में" झूठ बोलने वाले सभी तत्वों को std::vector<char> प्रकार के वेक्टर में जोड़ा जाएगा std::vector<char> । यदि हम भाग्यशाली हैं और ये दोनों स्ट्रिंग स्थिरांक एक पंक्ति में मेमोरी में हैं, तो तीन तत्व वेक्टर में गिर जाएंगे: 'h', 'i', '\ x00', लेकिन, सबसे अधिक संभावना है, इस तरह के कोड से मेमोरी सुरक्षा का उल्लंघन होगा और प्रोग्राम क्रैश हो जाएगा।

सामग्री का इस्तेमाल किया

ड्राफ्ट मानक C ++ 17
CTAD
CppCon 2018: Stephan T. Lavavej "सभी के लिए क्लास टेम्पलेट तर्क कटौती"