तर्कयुक्त कारखाना

आपका दिन शुभ हो!

कार्य

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

स्रोत डेटा

मान लें कि फ़ैक्टरी इंटरफ़ेस इस तरह दिखना चाहिए

class IFactoryBasic { public: IFactoryBasic() {} virtual ~IFactoryBasic() {} virtual Test* create(const QString &key, const QString &args)=0; }; 

जहां Test एक निश्चित आधार वर्ग है

 class Test { protected: QString _word; public: Test(const QString &word):_word(word) {} virtual ~Test() {} virtual void test(){ qDebug()<<"test "<<_word; } }; class TestChild: public Test { public: TestChild(const QString &word): Test(word) {} virtual void test() { qDebug()<<"test child"<<_word; } }; 

TestChild - Test के उत्तराधिकारी
दोनों वर्ग कंस्ट्रक्टर में एक स्ट्रिंग पैरामीटर word लेते हैं, जिसे हम test() फ़ंक्शन में सत्यापित कर सकते हैं।

पहला तरीका

विधि सरल है। यह भविष्य के कारखाने के लिए एक टेम्पलेट फ्रेम बनाने पर आधारित है।

 template<class T, class C, class A> class IFactory { QMap<QString, C* (T::*)(const A&) > handler; protected: void add(const QString &key, C *(T::*func)(const A &)) { handler[key]=func; } public: IFactory() {} virtual ~IFactory() {} C *make(const QString &key, const A &args) { if(handler.contains(key)) { T* inheritor = dynamic_cast<T*>(this); if(inheritor) return (inheritor->*handler[key])(args); } return 0; } }; 

वर्ग उपयोगकर्ताओं के लिए यहां एक छोटी सी प्रतिबद्धता है। पहला टेम्प्लेट पैरामीटर एक ऐसा वर्ग होना चाहिए जो इफैक्टिव से विरासत में मिला हो। अगला स्पष्टीकरण होगा कि यह क्यों आवश्यक था।
IFactory क्लास में handler एक एसोसिएटिव कंटेनर होता है जिसमें ऑब्जेक्ट बनाने के लिए कुंजी और संबंधित फ़ंक्शन होता है। पीढ़ी फ़ंक्शन के हस्ताक्षर को C* (T::*)(const A&) रूप में वर्णित किया गया C* (T::*)(const A&) , अर्थात, रिटर्न मान में एक निश्चित वर्ग C लिए एक सूचक होगा, एक फ़ंक्शन तर्क के रूप में, प्रकार A ऑब्जेक्ट का संदर्भ पास किया जाता है।
add(...) फ़ंक्शन एक कुंजी-फ़ंक्शन जोड़ता है <key,func> कंटेनर में जोड़ी।
make(...) फ़ंक्शन स्पॉन फ़ंक्शन को कॉल करता है, यदि यह कंटेनर में मौजूद है (पहले गतिशील रूप से this पॉइंटर के प्रकार को वारिस के प्रकार में परिवर्तित करता है, अन्यथा आप उन फ़ंक्शन को कॉल नहीं कर सकते हैं जो वहां परिभाषित किए गए थे)।
यह कारखाने का मुख्य फ्रेम है, यह एक विशिष्ट कारखाने का वर्णन करने के लिए रहता है

 class FactoryFst: public IFactory<FactoryFst, Test, QString>, public IFactoryBasic { Test *createOrigin(const QString &args){ return new Test(args); } Test *createChild(const QString &args) { return new TestChild(args); } public: FactoryFst() { add("test", &FactoryFst::createOrigin); add("testchild", &FactoryFst::createChild); } Test *create(const QString &key, const QString &args) { return make(key, args); } }; 

यह अनुमान लगाना आसान है कि हम IFactoryBasic इंटरफ़ेस की आवश्यकताओं को पूरा करने के लिए कई विरासत का उपयोग करते हैं। अन्य माता-पिता के लिए, हम स्पष्ट रूप से FactoryFst वंशज को निर्दिष्ट करते हैं, लौटा हुआ पॉइंटर Test क्लास के ऑब्जेक्ट के लिए एक पॉइंटर होगा, और QString ऑब्जेक्ट का एक संदर्भ एक तर्क के रूप में पारित किया जाएगा।
इस परिभाषा के अनुसार, फ़ंक्शन उत्पन्न होते हैं जो टाइप Test और TestChild की वस्तुओं को उत्पन्न करते हैं:
Test *createOrigin(const QString &args){ return new Test(args); } Test *createOrigin(const QString &args){ return new Test(args); } - निर्माणकर्ता को QString तर्क पास करते हुए, टाइप टेस्ट का एक ऑब्जेक्ट बनाता है।
Test *createChild(const QString &args) { return new TestChild(args); } Test *createChild(const QString &args) { return new TestChild(args); } - इसी तरह से TestChild प्रकार का ऑब्जेक्ट बनाता है।
वह सब IFactoryBasic कंस्ट्रक्टर में फ़ंक्शन डेटा को पंजीकृत करने और IFactoryBasic इंटरफ़ेस के create(...) IFactoryBasic परिभाषित करने के create(...) है।

दूसरा तरीका

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

पहले, हम पास किए गए तर्क के मूल्यों को संग्रहीत करने के लिए एक सहायक वर्ग को परिभाषित करते हैं। इस वर्ग के लिए स्वतंत्र रूप से पॉइंटर्स का उपयोग करने में सक्षम होने के लिए, हम इसे गैर-मानक बेस क्लास से विरासत में प्राप्त करेंगे।

 class Arguments { public: virtual ~Arguments() {} }; template<class T> class TArguments: public Arguments { public: T arg; TArguments(T _arg):arg(_arg) {} }; 

Arguments आधार वर्ग है, हस्तांतरित वस्तु को संग्रहित करने के लिए TArguments टेम्पलेट वर्ग है।

हमें new ऑपरेटर को आमंत्रित करने के लिए टेम्पलेट-रैपर क्लास की भी आवश्यकता है।

 class Container { public: virtual ~Container() {} virtual void *make( Arguments* ) = 0; }; 

एक गैर-टेम्पलेट Container Arguments के समान उद्देश्य प्रदान करता है। ताकि हम इसके किसी भी टेम्पलेट बच्चों के लिए हमेशा make(...) फंक्शन make(...) कह सकें। make(...) फ़ंक्शन को पॉइंटर को बनाई गई वस्तु पर वापस करना चाहिए।

 template<class T, typename A> class TContainer: public Container { public: void *make(Arguments* args=0) { TArguments<A>* a = dynamic_cast< TArguments<A>* >( args ); if(!a) return 0; return new T(a->arg); } }; 

TContainer क्लास पहले TContainer ही टेम्प्लेट है, क्योंकि टेम्प्लेट की दलीलें पास हो जाती हैं और लौटे पॉइंटर T का प्रकार और कंस्ट्रक्टर A का तर्क टाइप हो जाता है A
make(...) फ़ंक्शन में, Arguments लिए एक संकेतक को एक तर्क के रूप में पारित किया जाता है, लेकिन हम समझते हैं कि वास्तव में यह TArguments का सूचक होना चाहिए और प्रकार को गतिशील रूप से परिवर्तित करने का प्रयास करना चाहिए। यदि सभी परिवर्तन सफल रहे, तो हम पहले से परिभाषित प्रकार की एक वस्तु बना सकते हैं।

परिणामस्वरूप, फ़ैक्टरी फ़्रेम इस तरह दिखाई देगा:

 template<typename C=void, typename A=void> class TemplateFactory { QMap<QString, Container*> handler; public: TemplateFactory() {} virtual ~TemplateFactory(){ qDeleteAll(handler.values()); } template<class T> void add(const QString &name) { handler.insert(name, new TContainer<T, A>()); } C *make(const QString &name, const A &arg) { if(handler.contains(name)) return static_cast<C*>(handler.value(name)->make(new TArguments<A>(arg))); return 0; } }; 

यहाँ, टेम्पलेट तर्क C , आधार वर्ग है, A उत्पन्न वस्तुओं का निर्माता तर्क है।
add(...) फ़ंक्शन सूची में नई कक्षाओं को पंजीकृत करता है, make(...) एक क्लास ऑब्जेक्ट बनाता है, फ़ंक्शन के प्रकार और कंस्ट्रक्टर तर्क का चयन करने के लिए कुंजी पारित करता है। प्रकार * static_cast उपयोग void* प्रकार को C* बदलने के लिए किया C* है।
एक विशिष्ट कारखाना बनाने के लिए सब कुछ तैयार है।

 class FactorySnd: public TemplateFactory<Test, QString>, public IFactoryBasic { public: FactorySnd() { add<Test>("test"); add<TestCild>("testchild"); } Test* create(const QString &name, const QString &arg){ return make(name, arg); } }; 

एकाधिक वंशानुक्रम का फिर से उपयोग किया जाता है, create(...) फ़ंक्शन को फिर से परिभाषित किया जाता है। कंस्ट्रक्टर में, कक्षाएं पंजीकृत हैं।

परिणाम

दोनों फ़ैक्टरी काम करती हैं जैसा कि आप निम्न कोड चलाकर सत्यापित कर सकते हैं

  IFactoryBasic* factory = new FactorySnd(); Test* test = factory->create("test", "A"); test->test(); test = factory->create("testchild", "B"); test->test(); delete factory; factory = new FactoryFst(); Test *stest = factory->create("test", "C"); stest->test(); stest = factory->create("testchild", "D"); stest->test(); 

कंसोल में हमें निम्न निकास मिलता है:

 test "A" test child "B" test "C" test child "D" 

निष्कर्ष

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