मैं कैसे बूस्ट हूं। वह Boost.MPL के साथ दोस्त थे

हाल ही में मुझे कोड के साथ काम करना पड़ा जिसमें मानक एसटीएल कंटेनरों का उपयोग करके मनमाने प्रकारों के मापदंडों को पारित करने के कार्य को बढ़ावा दिया गया था :: कोई भी प्रकार।
उदाहरण के लिए:

void foo (std::vector<boost::any>& args) { // do smth. } 

पिछले डेवलपर बहुत सटीक नहीं था और फ़ंक्शन के अंदर, बूस्ट की सामग्री के साथ काम करना :: कोई भी मूल डेटा प्रकार की धारणा पर आधारित था, अर्थात, अगर रूपांतरण का रूपांतरण :: any_cast पास नहीं हुआ, तो पैरामीटर छोड़ दिया गया था। कुछ मामलों में, यह प्रसंस्करण विधि स्वीकार्य है और इस कार्य तकनीक के उदाहरण यहां मिल सकते हैं ।
हालाँकि, मैं डेटा प्रकार के बारे में कुछ प्रारंभिक मान्यताओं को सामान्य बनाना चाहता था।

ऐसी स्थिति की कल्पना करें जहां std :: वेक्टर में निम्न प्रकार के डेटा हों:
शॉर्ट, इंट, फ्लोट, डबल, और एक फंक्शन है

  double sum (std::vector<boost::any>& args) { } 

कंटेनर के प्रत्येक तत्व के लिए बढ़ावा देने वाले :: any_cast <double> को पारित मापदंडों के मूल्यों की राशि की गणना करता है।
आइए देखें कि क्या होता है जब बढ़ावा :: any_cast परिवर्तित हो जाता है

  template<typename ValueType> ValueType * any_cast(any * operand) { // // some code skipped // operand->type() == typeid(ValueType) ? &static_cast<any::holder<ValueType> *>(operand->content)->held : 0; } 

यदि मूल प्रकार का type_info मान और जिस प्रकार से रूपांतरण किया जाता है, वह मेल नहीं खाता है, तो 0. लौटाता है। लेकिन, सामान्य कार्य में, योग समारोह में लौटकर, हम खुद को लिखने में काफी सक्षम होते हैं

  double value=1+2L+3.0F+4.0; 

इस प्रकार int, long, float और double को जोड़ना। हम सम फ़ंक्शन से समान व्यवहार प्राप्त करना चाहते हैं।

यह है कि, जब प्रोसेशन :: किसी भी वैल्यू को प्रोसेस्ड करते हैं, तो हम यह कहना चाहते हैं: "अरे, फंक्शन 'स्मथ कास्ट (कोई भी)', यदि आप कर सकते हैं, तो किसी भी स्माट टाइप में कन्वर्ट कर सकते हैं।" और कास्ट फ़ंक्शन के लिए यह जानने के लिए कि यह किस प्रकार से Smth को जन्म दे सकता है, हमें प्रकारों की सूची चाहिए। वास्तव में, हम उन प्रकारों की एक सूची स्थापित करना चाहते हैं जिन्हें आसानी से आवश्यक प्रकार में परिवर्तित किया जा सकता है।
परिवर्तनीय प्रकारों की सूची का वर्णन करने के लिए, हम पहिया को सुदृढ़ नहीं करेंगे, लेकिन बढ़ावा दें :: mpl पुस्तकालय और हमें वहां आवश्यक प्रकार के दृश्यों की अवधारणा का पता लगाएं।

अब हमें बढ़ावा देने के विकल्प के रूप में टाइप कन्वर्टर क्लास की आवश्यकता है: any_cast, साथ ही टाइप कन्वर्टर क्लास, जो

1. उस प्रकार को स्वीकार करता है जिसे हम ToType में बदलना चाहते हैं
2. यह संगत प्रकारों की एक सूची को स्वीकार करेगा जिसमें से आवश्यक ToType प्रकार में रूपांतरण संभव है
3. बढ़ावा के आधार पर :: किसी भी वस्तु, यह हमें एक उपयुक्त प्रकार कनवर्टर लौटाएगा।

कनवर्टर वर्ग हमें आवश्यक प्रकार में परिवर्तित करने के लिए एक फ़ंक्शन प्रदान करता है, और उस प्रकार के type_info ऑब्जेक्ट में एक पॉइंटर भी संग्रहीत करता है जिससे वह रूपांतरण कर सकता है:

  template<class ToType> class Converter { public: virtual ~Converter {} virtual ToType cast(const boost::any& arg) = 0; explicit Converter(const type_info* info) : m_info(info) { } const type_info& type() { return *m_info; } private: const type_info* m_info; }; 

कास्ट फ़ंक्शन को विशुद्ध रूप से आभासी घोषित क्यों किया जाता है यह थोड़ा कम स्पष्ट हो जाएगा। अब हम वर्ग प्रेषण का वर्णन करते हैं:

  template<class CompatibleTypes, class ToType> class TypesDispatcher { std::vector<Converter<ToType>* > converters; struct wrapper { //code skipped }; public: TypesDispatcher(); Converter<ToType>* getConverter(const boost::any& arg); }; 

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

  template <class FromType, class ToType> class TypeConverter : public Converter<ToType> { public: TypeConverter() : Converter(&typeid(FromType)) { } virtual ToType cast(const boost::any& arg) { return static_cast<ToType>(*boost::any_cast<FromType>(&arg)); } }; 

अब हमारे पास सभी प्रकार के कम्पैटिबलटेप्स के लिए कनवर्टर ऑब्जेक्ट बनाने के लिए सब कुछ है, साथ ही साथ गेटकॉर्टर फ़ंक्शन को लागू करना है।

  //      struct wrapper { explicit wrapper(std::vector<Converter<ToType>* >& converters) : m_converters(converters) { } template<class FromType> void operator()(FromType) { m_converters.push_back(new TypeConverter<FromType, ToType>()); } std::vector<Converter<ToType>* >& m_converters; }; //    TypesDispatcher() { boost::mpl::for_each<CompatibleTypes>(wrapper(converters)); } 

कम्पेटिबलटेप्स के प्रकारों की सूची के माध्यम से जाने के लिए हमने बढ़ावा दिया :: mpl :: for_each, जो एक ऑब्जेक्ट को एक फंक्शन लेता है जो रन टाइम में सूची में प्रत्येक प्रकार पर लागू होता है, इस प्रकार के लिए प्रत्येक प्रकार की ऑब्जेक्ट को त्वरित करता है।
GetConverter फ़ंक्शन का कार्यान्वयन सरल और स्पष्ट है:

  Converter<ToType>* getConverter(const boost::any& arg) { std::vector<Converter<ToType>* >::const_iterator it = converters.begin(); while(it != converters.end() ) { Converter<ToType>* converter = *it; if(converter->type() == arg.type()) return converter; ++it; } return 0; } 

वह सब है। अब हम कुछ ऐसा लिख ​​सकते हैं

  template<class CompatibleTypes, class ReturnType> ReturnType sum(std::vector<boost::any>& args) { TypesDispatcher<CompatibleTypes, ReturnType> dispatcher; std::vector<boost::any>::size_type i; ReturnType result = ReturnType(); for(i=0; i < args.size(); i++) { Converter<ReturnType>* converter = dispatcher.getConverter(args[i]); if(converter) result += converter->cast(args[i]); } return result; } int main(int argc, char* argv[]) { typedef boost::mpl::vector<int,long, float, double> types; std::vector<boost::any> seq; seq.push_back(boost::any( 1 )); seq.push_back(boost::any( 2L )); seq.push_back(boost::any( 3.0F )); seq.push_back(boost::any( 4.0 )); double result = sum<types, double>(seq); } 

पूरा कोड उदाहरण यहां पाया जा सकता है ।

नतीजतन, हमें मनमाने प्रकार के तर्कों के साथ काम करने का अवसर मिला, अपेक्षाकृत लचीलेपन ने उनके रूपांतरण के नियमों को निर्धारित किया।