टाइपलिस्ट और टिक टीएसी को पैर की अंगुली

मैं अंत में चाहता था (!) variadic templates



कोशिश करने के लिए, जैसा कि मैं अभी भी 10 वीं स्टूडियो से बंधा हुआ हूं, जहां इसमें से कोई भी नहीं है। और लंबे समय तक यह नहीं सोचने के लिए कि वेरिएडिक टेम्प्लेट का उपयोग करना कहां तक ​​बेकार है, यह विचार करने की कोशिश की गई कि टाइपेलिस्ट कैसा दिखेगा। उन लोगों के लिए जो अभी भी नहीं जानते कि यह क्या है, मैं रास्ते में समझाने की कोशिश करूंगा, और जो लोग ऊब गए हैं - तुरंत नीचे स्क्रॉल कर सकते हैं - Typelist



का उपयोग करके एक प्रकार का टिक-टैक-टो लिखने की कोशिश करें।

तो TypeList



:





एक विशिष्ट TypeList



एक "हेड" और एक "टेल" है, जो बदले में भी प्रकारों की एक सूची है। का उपयोग करें:

 typedef TypeList<float, double, long double> floating_point_types;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पहले, C ++ 11 के बिना, यह इस तरह दिखता था:



लेकिन अब, variadic templates



लिए धन्यवाद, आप सूची में मैक्रो और प्रकार की संख्या पर सीमा से छुटकारा पा सकते हैं।

वास्तव में, दिलचस्प यह है कि किस प्रकार की सूची के साथ काम करना है, उस पर संचालन को कैसे परिभाषित करना है और यह आखिर में क्या देता है (जो अधिक विस्तृत विवरण में रुचि रखते हैं और जिन्होंने आधुनिक सी ++ डिजाइन नहीं देखा है - मैं आपको पढ़ने के लिए सलाह देता हूं - यह कोई फर्क नहीं पड़ता कि यह 2001 है! )।

इसलिए, जैसा कि आप देख सकते हैं, मैंने सहायक प्रकार internal::Void



परिभाषित किया, जो सिग्नल ध्वज के रूप में काम करेगा और कहेगा कि प्रकार की सूची खाली है (कम से कम उस स्थिति के लिए जब उपयोगकर्ता ने कुछ भी निर्दिष्ट नहीं किया है: TypeList<>



, या सूची से जब सभी आइटम हटाए गए)। चलिए शुरू से शुरू करते हैं:

IsEmpty

यहां आप लगभग सभी चीजें देख सकते हैं जिन्हें हमें अन्य कार्यों को परिभाषित करने की आवश्यकता है। जैसा कि आप देख सकते हैं, हम पहले "बैकबोन" को परिभाषित करते हैं: IsEmpty



प्रकार को एक प्रकार से पैरामीटरित किया जाता है। संक्षेप में, यह एक "फ़ंक्शन" है जो एक तर्क लेता है। चूंकि टाइप TL



अर्थ है "किसी भी प्रकार", हम खाली सूची के साथ मामले के लिए टेम्पलेट का एक पूर्ण विशेषज्ञता करते हैं: TypeList<internal::Void, internal::Void>



(यह संभव होगा TypeList<>



या, बस उसके लिए, मैं परिभाषित प्रकार EmptyTypeList



) और एक आंशिक विशेषज्ञता जो काम करती है - "किसी भी प्रकार की सूची के लिए।" इस प्रकार, हमारे "फ़ंक्शन" को केवल प्रकारों की सूची के लिए परिभाषित किया गया है। एसटीडी जैसी सुविधाजनक चीजें :: इंटीग्रल_कॉन्स्टेंट नए मानक में दिखाई दी हैं, जो जीवन को बहुत सरल बनाती हैं: struct IsEmpty : std::true_type



के मामले में struct IsEmpty : std::true_type



, struct IsEmpty : std::true_type



में value



वर्ग का एक सदस्य, कई प्रकार के typedef



और एक रूपांतरण ऑपरेटर है।

इसका उपयोग कैसे करें?:

 typedef TypeList<int> TL1; std::cout << std::boolalpha << IsEmpty<TL1>::value << " " << IsEmpty<EmptyTypeList>() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

क्या हमारे पास एक खाली सूची है, जो निम्नलिखित अभिव्यक्ति को परिभाषित करती है:

 std::is_same<typename TypeList<Args...>::Head, internal::Void>::value && IsEmpty<typename TypeList<Args...>::Tail>::value
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वस्तुतः - "सूची खाली है यदि उसका सिर एक सहायक प्रकार है जो void



को निरूपित करता void



और यदि उसकी पूंछ भी एक खाली सूची है।" जैसा कि आप देख सकते हैं, यहां पुनरावृत्ति का उपयोग किया जाता है, जो खाली सूची के लिए टेम्पलेट के पूर्ण विशेषज्ञता को रोकता है।

अगले:

शामिल

यदि निर्धारित T



टाइप TL



प्रकार की सूची के अंदर है, तो यह निर्धारित करता है। का उपयोग करें:



का उपयोग करें:

 typedef TypeList<double, float, float, double, int, char, char, int, char> TL; std::cout << std::boolalpha << Contains<char, TL>::value << " " << Contains<float, TypeList<double>>() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

दोबारा: "यदि सूची का प्रमुख हमारे प्रकार T



, तो T



सूची के अंदर है, अन्यथा, देखें कि क्या T



सूची की पूंछ पर है।"

आंशिक विशेषज्ञता - एक एहतियाती उपाय - क्या होगा यदि कोई हमारे प्रकार का उपयोग करता है internal::Void



?

लंबाई

यदि सूची खाली है, तो लंबाई शून्य है, अन्यथा यह एक है (क्योंकि "हेड" है) + पूंछ की लंबाई:

 typedef TypeList<double, float, float, double, int, char, char, int, char> TL; std::cout << Length<TL>::value << " " << Length<EmptyTypeList>() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

TypeAt

 template<unsigned int N, typename TL> struct TypeAt { typedef internal::Void type; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

- अनुक्रमणिका के प्रकार, लगभग एक सरणी की तरह। कार्यान्वयन पहली कॉल है (हम टाइप N



को int



बदलते हैं):

 //template<int N, typename ...Args> //struct TypeAt<N, TypeList<Args...>> //{ // typedef typename std::conditional<N == 0, // typename TypeList<Args...>::Head, // typename TypeAt<N - 1, typename TypeList<Args...>::Tail>::type>::type type; //};
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

- सब कुछ ठीक काम करेगा, लेकिन! - यदि सूचकांक बहुत बड़ा है तो मुझे चेतावनी दी जाएगी। वर्तमान कार्यान्वयन के साथ बाहर निकलना संभव होगा, लेकिन यहां यह ध्यान में रखा जाना चाहिए कि मामले N=-1



लिए टेम्पलेट को सही ढंग से तत्काल किया जाना चाहिए। इसलिए, हम दूसरे तरीके से चलते हैं:

 template<typename ...Args> struct TypeAt<0, TypeList<Args...>> { typedef typename TypeList<Args...>::Head type; }; template<unsigned int N, typename ...Args> struct TypeAt<N, TypeList<Args...>> { static_assert(N < Length<TypeList<Args...>>::value, "N is too big"); typedef typename TypeAt<N - 1, typename TypeList<Args...>::Tail>::type type; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 typedef TypeList<char, short> TL2; static_assert(std::is_same<TypeAt<1, TL2>::type, short>::value, "Something wrong!");
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सूची उत्पादन

ये कार्य उदाहरण के लिए नियमित प्रकार की सूचियों और नेस्टेड लोगों को सही ढंग से प्रदर्शित करने में मदद करते हैं:

 typedef TypeList<double, float, float, double, int, char, char, int, char> TL; std::cout << TL() << std::endl; typedef TypeList<TL2, double, TL2> TL10; std::cout << TL10() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{double float float double int char char int char}







{{char short} double {char short}}



जोड़ें और जोड़ें

पहले तर्क में प्रकारों की सूची के साथ Append



का उपयोग करते समय, घटकों में एक "अपघटन" होता है। यानी:

 typedef TypeList<int> TL1; typedef TypeList<char, short> TL2; std::cout << TL1() << ", " << TL2() << std::endl; std::cout << Add<TL2, TL1>::type() << ", " << Append<TL2, TL1>::type() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{int}, {char short}





{int {char short}}, {int char short}





पहले मामले में, परिणाम की लंबाई 2 है, जबकि दूसरे में यह 3 है, क्योंकि घटकों में "विघटित" प्रकारों की अतिरिक्त सूची।

RemoveAll

निष्कासन इस तरह किया जाता है:

• हम खाली सूची में से कुछ भी नहीं हटा सकते हैं
• यदि हमारे पास एक तत्व (केवल सिर) के साथ एक सूची है, तो एक खाली सूची लौटाएं यदि सिर का प्रकार निर्दिष्ट एक से मेल खाता है या अन्यथा बदल जाता है
• अन्य सभी मामलों के लिए - पूंछ से तत्वों को हटा दें, और यदि सिर का प्रकार निर्दिष्ट प्रकार से मेल नहीं खाता है - इसे हटाए गए परिणाम से पहले जोड़ें

महत्वपूर्ण बात यह है कि जब हमने पूंछ से परिणाम निकाला तो हमने परिणाम को अन्य प्रकार की सूची में वर्गीकृत किया, जब संयुक्त होता है, तो हम Append



उपयोग करते हैं, जो प्रकारों की समूहीकृत सूची को "अनइंडेंड" करता है।

का उपयोग करें:

 typedef TypeList<double, float, float, double, int, char, char, int, char> TL; std::cout << TL() << std::endl; std::cout << RemoveAll<char, TL>::type() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{double float float double int char char int char}





{double float float double int int}







आप RemoveAll



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





एक उदाहरण:

 typedef TypeList<double, float, float, double, int, char, char, int, char> TL; typedef TypeList<char, double> TL2; std::cout << TL() << std::endl; std::cout << RemoveAll<TL2, TL>::type() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{double float float double int char char int char}





{float float int int}

RemoveDuplicates

डुप्लिकेट को हटाने वाला कार्य:

• हम खाली सूची में से कुछ भी नहीं हटा सकते हैं
• हम पूंछ से सिर के समान तत्वों को हटाते हैं
• पुनरावर्ती पूंछ के लिए एक समारोह कहते हैं
• परिणाम के साथ सिर को मिलाएं

एक उदाहरण:

 typedef TypeList<double, float, float, double, int, char, char, int, char> TL; std::cout << TL() << std::endl; std::cout << RemoveDuplicates<TL>::type() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{double float float double int char char int char}





{double float int char}

खोज

कुछ बातें:

- Constants



- स्थिरांक के लिए। हमारे मामले में, केवल एक स्थिरांक के लिए जो कहता है कि तत्व नहीं मिला था (मेरे स्टूडियो में कॉन्स्टैक्स समर्थित नहीं है, इसलिए UINT_MAX



)

- internal::FindHelper



- वास्तव में, एक "चीज़" जो सूची में एक प्रकार की खोज करती है जो वास्तव में (!) इस प्रकार में है (एक अतिरिक्त IndexFrom



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



फिर से - कुछ भी जटिल नहीं है - यदि निर्दिष्ट प्रकार और सूची के प्रमुख के प्रकार समान हैं - तो सूचकांक शून्य है, अन्यथा यह 1tsu द्वारा दाईं ओर ले जाएगा और सूची की पूंछ के लिए भी ऐसा ही करेगा।

एक उदाहरण:

 typedef TypeList<double, float, float, double, int, char, char, int, char> TL; std::cout << std::boolalpha << std::is_same<TypeAt<Find<double, TL>::value, TL>::type, double>() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

टुकड़ा

सूची का निर्दिष्ट भाग "कट्स":

• हम खाली सूची से कुछ भी नहीं ले सकते
• जब निर्दिष्ट प्रारंभ ( IndexBegin
  
  
  
  ) और अंत ( IndexEnd
  
  
  
  ) मेल खाते हैं, तो यह TypeAt
  
  
  
  ऑपरेशन के समान है
  
  निर्दिष्ट सीमा के अंत से शुरू करते हुए, तत्व ले लो और पुनरावर्ती कॉल के परिणाम में जोड़ें (जिसमें निर्दिष्ट सीमा का अंत 1 सीयू से कम हो जाता है)
  
  




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