टेम्प्लेट आरंभीकरण सूची का मनमाना क्रम

मुझे लगता है कि कई जो टेम्पलेट के साथ काम करते हैं वे निम्नलिखित स्थिति से परिचित हैं। हमारे पास टेम्प्लेट मापदंडों के एक समूह के साथ एक निश्चित टेम्प्लेट क्लास है

struct deferred; struct deadline; struct disable; template<class T, class Deferred = disable, class Deadline = disable> struct some_container
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 typedef some_container<int, disable, deadline> deadline_container; <source>    <source lang=cpp> typedef some_container<int, deadline> deadline_container;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

बेहतर अभी तक, असाइनमेंट का क्रम भी मायने नहीं रखता है और अगले दो बराबर हैं

 typedef some_container<int, deferred, deadline> full_container1; typedef some_container<int, deadline, deferred> full_container1;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लेकिन हम अच्छी तरह से जानते हैं कि जैसे ही हम दो मापदंडों को बदलते हैं, हम जो उम्मीद करते हैं उससे पूरी तरह से अलग हो जाते हैं (यह आपके लिए कोई तुक नहीं है जहां संकेत देने वाला आदेश कोई फर्क नहीं पड़ता)

मुझे लगता है कि कई लोगों ने पहले ही सोचा है कि यह सब हमारे प्रकार और उपयोगकर्ता के बीच एक परत जोड़कर प्राप्त किया जा सकता है, जिसके लिए सभी संभव विशेषज्ञताओं को लिखना है। यदि आपके पास केवल 2 टेम्पलेट पैरामीटर हैं, तो हाँ, यदि 3 पहले से ही मुश्किल है, और यदि 4, 5 जोड़ा गया है, तो लिखना गायब है। और एक नियम के रूप में, एक नए पैरामीटर को जोड़ने से पिछले सभी विशेषज्ञताओं को फिर से परिभाषित किया जाता है (क्योंकि विशेषज्ञता में हम टेम्पलेट मापदंडों की संख्या में वृद्धि नहीं कर सकते हैं, लेकिन हम केवल उन्हें कम कर सकते हैं)।

यदि आप रुचि रखते हैं, तो मैं कटौती के लिए कहता हूं, मैं आपको दिखाऊंगा कि इसे कैसे प्राप्त किया जाए



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

 typedef some_container<int, disable, deadline_super>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लेकिन आप तंत्र में इस प्रकार का उपयोग नहीं कर सकते हैं जो आपको टेम्पलेट को एक मनमाने रूप में विशेषज्ञ करने की अनुमति देगा। शायद यह एकमात्र गंभीर सीमा है। इस पहलू को देखते हुए, यह स्पष्ट हो जाता है कि यह तंत्र अतिसूक्ष्म या बहुरूपी के बजाय मॉड्यूलर घटकों को लिखते समय उपयोग करने के लिए सुविधाजनक है।

पूरा कार्यान्वयन mpl :: set के रूप में इस तरह के एक बढ़ावा घटक पर आधारित है। मैं इस बात पर ज्यादा बात नहीं करूंगा कि :: mpl क्या है , मैं सिर्फ इतना कहूंगा कि mpl :: सेट आपको std के समान एक कंटेनर बनाने की अनुमति देता है :: सेट लेकिन संकलन चरण और प्रकारों से मिलकर।

पहली चीज़ जो हमें चाहिए वो है टाइप के लिस्ट को चेक करने की एक ज़रुरत जिसे हम चाहते हैं, और कुछ डिफॉल्ट वैल्यू (स्ट्रक्चर डिसेबल) वापस करें

 template <class Plugin, class IsSet> struct get_plugin_impl; template <class Plugin> struct get_plugin_impl<Plugin, boost::mpl::false_> { typedef disable_plugin type; }; template <class Plugin> struct get_plugin_impl<Plugin, boost::mpl::true_> { typedef Plugin type; }; template <class List, class Plugin> struct get_plugin { typedef typename get_plugin_impl<Plugin, typename boost::mpl::has_key<List, Plugin>::type>::type type; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

अगले चरण में, हम सभी प्रकारों को परिभाषित करते हैं जो अंतिम टेम्पलेट में उपयोग किए जाते हैं

 template <class List> struct get_plugins { typedef typename get_plugin<List, deferred_plugin>::type deferred; typedef typename get_plugin<List, deadline_plugin>::type deadline; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और यह वह जगह है जो नए टेम्पलेट मापदंडों को जोड़ने पर बदल जाएगी। लेकिन यह बहुत आसान है, और कोई 2 ^ n संयोजनों को सूचीबद्ध करने की आवश्यकता नहीं है।

अगला, हम अंतिम टेम्पलेट प्रकार और उपयोगकर्ता के बीच एक परत पेश करते हैं

 template<class T, class P1 = disable_plugin, class P2 = disable_plugin> struct container { typedef boost::mpl::set<P1, P2> plugin_list; typedef get_plugins<plugin_list> plugs; typedef typename plugs::deferred deferred; typedef typename plugs::deadline deadline; typedef some_container<T, deferred, deadline> type; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अर्थात्, यह हमें टेम्पलेट मापदंडों को निर्दिष्ट करने की संख्या और क्रम से अमूर्त करने की अनुमति देता है। वास्तव में, यह उन सभी (2 ^ n + K) विशिष्टताओं को जोड़ती है जो हमें दिए गए टेम्पलेट मापदंडों की एक अलग संख्या और उनके आदेश के लिए लिखना होगा।



हमारे टेम्प्लेट प्रकार पर लौटकर, मैं आपको दिखाऊंगा कि यह कैसे काम करता है

 #define static_type(name) \ static const std::string& type() \ { \ static std::string type_(name); \ return type_; \ } \ struct deferred_plugin { static_type("deferred"); }; struct deadline_plugin { static_type("deadline"); }; struct disable_plugin { static_type("disable"); }; template<class T, class Deferred, class Deadline> struct some_container { static const std::string& type() { static std::string type_("some_container<" + Deferred::type() + ", " + Deadline::type() + ">"); return type_; } };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

के उपयोग

  cout << container<int>::type::type() << std::endl; cout << container<int, deadline_plugin>::type::type() << std::endl; cout << container<int, deferred_plugin>::type::type() << std::endl; cout << container<int, deferred_plugin, deadline_plugin>::type::type() << std::endl; cout << container<int, deadline_plugin, deferred_plugin>::type::type() << std::endl;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निकास

some_container <अक्षम करें, अक्षम करें>

some_container <अक्षम, समय सीमा>

some_container <आस्थगित, अक्षम>

some_container <स्थगित, समय सीमा>

some_container <स्थगित, समय सीमा>

कृपया ध्यान दें कि खाका तैयार करते समय जिस प्रकार को निर्दिष्ट किया गया था, उस पर ध्यान दिए बिना विशेषज्ञता के क्रम को सही रूप में सहेजा गया है।



बस इतना ही, मुझे उम्मीद है कि इससे किसी को कोड को अधिक सुंदर और सटीक बनाने में मदद मिलेगी।

स्रोत: git