🖐🏼 👤 🔓 ऑब्जेक्ट को स्ट्रीम, ऑब्जेक्ट फ़ैक्टरी पैटर्न पर रखें 🤶🏼 🦊 👩🏾‍🤝‍👩🏼

शुभ दिन, पाठक। मैं आपके साथ अपने ज्ञान का सबसे अधिक उपयोग किए जाने वाले पैटर्नों में से एक के बारे में अपने ज्ञान को साझा करना चाहता हूं - वस्तुओं का कारखाना, एक अन्य नाम भी इस पैटर्न के लिए उपयुक्त है - एक आभासी निर्माता।

यह कैसा पैटर्न है?

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

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

एक विशिष्ट कारखाने का निर्माण

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

lass FooFactory { public: FooFactory(); ~virtual FooFactory(); Foo * create(const std::string & id) const; };

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

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

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

लेकिन दूसरी ओर, C ++ में ऐसे टेम्पलेट हैं जो इस कठिन कार्य को हल करने में मदद करेंगे। फू के प्रकार की वस्तुओं को बनाने के लिए, हम अन्य वस्तुओं, सहायक वाले का उपयोग करेंगे, जो हमें उस वर्ग की वस्तुओं को बनाने का काम लेगा जिसकी हमें आवश्यकता है। आम लोगों में, ऐसे वर्गों को निर्माता या तात्कालिक कहा जाता है। एक अमूर्त निर्माता वर्ग बनाया जाता है, जिसमें आमतौर पर केवल एक ही विधि होती है - एक निश्चित इंटरफ़ेस का एक ऑब्जेक्ट बनाना, वर्तमान संस्करण में, फू की वस्तुएं। और इसके आधार पर, पहले से ही रचनाकारों के ठोस वर्ग बनाए जा रहे हैं। अमूर्त निर्माता वर्ग के लिए धन्यवाद, हम किसी भी कंटेनर में विशिष्ट रचनाकारों का एक सेट स्टोर कर सकते हैं। इस मामले में, टेम्पलेट मैक्रोज़ की भूमिका निभाएंगे, जो आपको टेम्पलेट पैरामीटर के आधार पर एक विशिष्ट निर्माता के लिए कोड उत्पन्न करने की अनुमति देगा।

प्रकार फू की वस्तुओं को बनाने के लिए एक सार वर्ग:

 class abstractFooCreator { public: virtual fooCreator() {} virtual Foo * create() const = 0; };

और एक खाका वर्ग जिसमें एक विशेष वर्ग की वस्तु बनाने के लिए वास्तविक कोड उत्पन्न किया जाएगा:

 template <class C> class fooCreator : public abstractFooCreator { public: virtual Foo * create() const { return new C(); } };

इस प्रकार, हम पहले से ही कारखाने के लिए एक वर्ग जोड़ने के लिए हमारे टेम्पलेट विधि लिख सकते हैं। केवल एक चीज जो हमें चाहिए वह है कि हम अपने रचनाकारों को संचय करने के लिए एक कंटेनर चुनें। स्पष्ट विकल्प std :: मानचित्र होगा।

 typedef std::map<std::string, abstractFooCreator*> FactoryMap; FactoryMap _factory; template <class C> void add(const std::string & id) { typename FactoryMap::iterator it = _factory.find(id); if (it == _factory.end()) _factory[id] = new fooCreator<C>(); }

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

 void Foo * create(const std::string & id) const { typename FactoryMap::iterator it = _factory.find(id); if (it != _factory.end()) return it->second->create(); return 0; }

पूरी तस्वीर देखने के लिए सभी कोड इकट्ठा करते हैं।

खुला है

 class abstractFooCreator { public: virtual fooCreator() {} virtual Foo * create() const = 0; }; template <class C> class fooCreator : public abstractFooCreator { public: virtual Foo * create() const { return new C(); } }; lass FooFactory { protected: typedef std::map<std::string, abstractFooCreator*> FactoryMap; FactoryMap _factory; public: FooFactory(); ~virtual FooFactory(); template <class C> void add(const std::string & id) { typename FactoryMap::iterator it = _factory.find(id); if (it == _factory.end()) _factory[id] = new fooCreator<C>(); } Foo * create(const std::string & id) { typename FactoryMap::iterator it = _factory.find(id); if (it != _factory.end()) return it->second->create(); return 0; } };

खैर, इस कारखाने का उपयोग कैसे करें का एक छोटा सा उदाहरण। कारखाने में कक्षाएं जोड़ना:

 FooFactory factory; factory.add<MyFoo>("MyFoo"); factory.add<MyFoo2>("MyFoo2"); factory.add<ImprovedFoo>("ImprovedFoo");

एक कारखाने का उपयोग करके एक वस्तु बनाना:

 Foo * p = factory.create("MyFoo2");

यह एक कारखाने की मदद से इतना सरल है, आप उन वस्तुओं के निर्माण को नियंत्रित कर सकते हैं जो एकल इंटरफ़ेस का समर्थन करते हैं।

एक टेम्पलेट फैक्टरी बनाना

खैर, अब आइए, इस विशिष्ट उदाहरण के आधार पर, एक बहुत विशिष्ट पैटर्न बनाते हैं।

हमारे कारखाने को हमारी क्षमताओं को संतुष्ट करने की क्या आवश्यकता है? बेशक, यह एक पहचानकर्ता प्रकार का काम है, जो या तो एक एनुम, एक std :: string, या पहचानकर्ता के लिए उपयुक्त किसी अन्य प्रकार का हो सकता है। दूसरा वास्तविक प्रकार का ऑब्जेक्ट है जिसे हम बनाएंगे, ऊपर के उदाहरण में भूमिका फू कक्षा द्वारा निभाई गई थी।

 template <class Base, class IdType> class ObjectFactory { public: ObjectFactory() {} virtual ~ObjectFactory(); template <class C> void add(const IdType & id); Base * create() const; };

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

 template <class Base> class AbstractCreator { public: AbstractCreator() {} virtual ~AbstractCreator(){} virtual Base* create() const = 0; }; template <class C, class Base> class Creator : public AbstractCreator<Base> { public: Creator() { } virtual ~Creator() {} Base * create() const { return new C(); } };

खैर, अब आपको हमारे कारखाने में इन वर्गों का उपयोग करने की आवश्यकता है।

 template <class Base, class IdType> class ObjectFactory { protected: typedef AbstractCreator<Base> AbstractFactory; typedef std::map<IdType, AbstractFactory*> FactoryMap; FactoryMap _factory; public: ObjectFactory() {} virtual ~ObjectFactory(); template <class C> void add(const IdType & id) { registerClass(id, new Creator<C, Base>()); } protected: void registerClass(const IdType & id, AbstractFactory * p) { typename FactoryMap::iterator it = _factory.find(id); if (it == _factory.end()) _factory[id] = p; else delete p; } };

फू उदाहरण के साथ तुलना में क्या जोड़ा गया है? बेशक, यह रजिस्टरक्लास विधि है, जो एक पैरामीटर के रूप में एब्सट्रैक्ट के प्रकार को लेती है, जो बदले में, क्लास की उन वस्तुओं को बना सकती है जिन्हें हम ऐड विधि के लिए टेम्पलेट पैरामीटर के रूप में निर्दिष्ट करते हैं।

कारखाना व्यवहार सेट करने की क्षमता जोड़ें

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

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

 template <class Base, class Type> class ObjectFactoryIgnoreErrorPolicy { public: Base * onCreateFailed(const Type & type) const { return 0; } void onRemoveFailed(const Type & type) {} void onDuplicateRegistered(const Type & type) {} };

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

कार्यान्वयन का उदाहरण

 class ObjectFactoryException : public std::exception { std::string _msg; public: ObjectFactoryException(const std::string & msg) throw() : _msg(msg) {} virtual ~ObjectFactoryException() throw() {} virtual const char * what() const throw() { return _msg.c_str(); } }; template <class Base, class Type> class ObjectFactoryThrowExceptionErrorPolicy { public: std::string generateMessage(const char * msg, const Type & type) const { std::stringstream strm; strm << msg << ", requested type id : " << type; return strm.str(); } Base * onCreateFailed(const Type & type) const { throw ObjectFactoryException(generateMessage("ObjectFactory - can't create object (not registered)", type)); } void onRemoveFailed(const Type & type) { throw ObjectFactoryException(generateMessage("ObjectFactory - can't remove class (not registered)", type)); } void onDuplicateRegistered(const Type & type) { throw ObjectFactoryException(generateMessage("ObjectFactory - class already registered", type)); } };

अब कारखाने में हमारी नीति को एम्बेड करें। ऐसा करने के कई तरीके हैं - बस नीति वर्ग से विरासत में मिला है, या कारखाने की विशेषता के रूप में नीति वर्ग का उपयोग करें। दोनों ही मामलों में, एकमात्र समस्या यह है कि कारखाना वर्ग से नीति वर्ग के लिए टेम्पलेट पैरामीटर कैसे सेट करें। C ++ की उल्लेखनीय विशेषता हमें इसके साथ मदद करेगी - टेम्पलेट टेम्पलेट पैरामीटर। फैक्ट्री क्लास की घोषणा करते समय, हम संकेत देते हैं कि हम केवल एक क्लास नहीं, बल्कि टेम्प्लेट क्लास के पैरामीटर के रूप में उत्तीर्ण होना चाहते हैं। यह इस तरह दिखेगा:

 template <class Base, class IdType, template <class, class> class ObjectFactoryErrorPolicy = ObjectFactoryIgnoreErrorPolicy > class ObjectFactory : public ObjectFactoryErrorPolicy<Base, IdType> { …

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

 typedef ObjectFactory<Foo, FooType, ObjectFactoryThrowExceptionPolicy> FooFactory;

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

लिस्टिंग

खैर, अब स्टॉक लेने और मेरे कार्यान्वयन के साथ पैटर्न की पूरी सूची पेश करने का समय है।

लिस्टिंग

 #include <map> #include <string> #include <memory> #include <sstream> namespace grs { /*  ,       */ template <class Base> class AbstractCreator { public: AbstractCreator() { } virtual ~AbstractCreator() { } virtual Base* create() const = 0; private: AbstractCreator(const AbstractCreator&); AbstractCreator& operator = (const AbstractCreator&); }; template <class C, class Base> class Creator : public AbstractCreator<Base> { public: Creator() { } virtual ~Creator() { } Base * create() const { return new C(); } }; /*    */ class ObjectFactoryException : public std::exception { std::string _msg; public: ObjectFactoryException(const std::string & msg) throw() : _msg(msg) {} virtual ~ObjectFactoryException() throw() {} virtual const char * what() const throw() { return _msg.c_str(); } }; template <class Base, class Type> class ObjectFactoryIgnoreErrorPolicy { public: Base * onCreateFailed(const Type & type) const { return 0; } void onRemoveFailed(const Type & type) { } void onDuplicateRegistered(const Type & type) { } }; template <class Base, class Type> class ObjectFactoryThrowExceptionErrorPolicy { public: std::string generateMessage(const char * msg, const Type & type) const { std::stringstream strm; strm << msg << ", requested type id : " << type; return strm.str(); } Base * onCreateFailed(const Type & type) const { throw ObjectFactoryException(generateMessage("ObjectFactory - can't create object (not registered)", type)); } void onRemoveFailed(const Type & type) { throw ObjectFactoryException(generateMessage("ObjectFactory - can't remove class (not registered)", type)); } void onDuplicateRegistered(const Type & type) { throw ObjectFactoryException(generateMessage("ObjectFactory - class already registered", type)); } }; /*  */ template <class Base, class IdType = int, template <class, class> class ObjectFactoryErrorPolicy = ObjectFactoryIgnoreErrorPolicy > class ObjectFactory : public ObjectFactoryErrorPolicy<Base, IdType> { protected: typedef AbstractCreator<Base> AbstractFactory; typedef std::map<IdType, AbstractFactory*> FactoryMap; public: ObjectFactory() { } virtual ~ObjectFactory() { for (typename FactoryMap::iterator it = _map.begin(), endIt = _map.end(); it != endIt; ++it) delete it->second; } Base * create(const IdType & id) const { typename FactoryMap::const_iterator it = _map.find(id); if (it != _map.end()) return it->second->create(); return onCreateFailed(id); } template <class C> void add(const IdType & id) { registerClass(id, new Creator<C, Base>); } void remove(const IdType & id) { typename FactoryMap::iterator it = _map.find(id); if (it != _map.end()) { delete it->second; _map.erase(it); } else onRemoveFailed(id); } bool isRegistered(const IdType & id) const { return _map.find(id) != _map.end(); } size_t size() const { return _map.size(); } protected: void registerClass(const IdType & id, AbstractFactory * pAbstractFactory) { std::auto_ptr<AbstractFactory> ptr(pAbstractFactory); typename FactoryMap::iterator it = _map.find(id); if (it == _map.end()) _map[id] = ptr.release(); else onDuplicateRegistered(id); } private: ObjectFactory(const ObjectFactory&); ObjectFactory& operator = (const ObjectFactory&); FactoryMap _map; }; } // end of grs namespace

एक कारखाने का उपयोग करने का एक छोटा सा उदाहरण

 #include "ObjectFactory.h" #include <iostream> enum Type { fooType, barType, maskedType, unknownType, firstType = fooType, lastType = maskedType, }; std::ostream & operator << (std::ostream & strm, const Type & type) { const char * names[] = {"foo", "bar", "masked"}; if (type < firstType || type > lastType) return strm << "unknown type(" << int(type) << ")"; return strm << names[type]; }; class Base { public: virtual ~Base() {} virtual Type type() const = 0; }; class Foo : public Base { public: virtual Type type() const { return fooType; } }; class Bar : public Foo { public: virtual Type type() const { return barType; } }; class MaskedFoo : public Foo { public: virtual Type type() const { return barType; } }; typedef grs::ObjectFactory<Base, Type> TypeFactory; void checkType(TypeFactory & factory, Type type) { std::auto_ptr<Base> p; p.reset(factory.create(type)); std::cout << "Object with type : " << type; if (p.get()) { if (type == p->type()) std::cout << " - successfully created\n"; else std::cout << " - created, but type mismatch\n"; } else std::cout << " - create failed\n"; } int main() { TypeFactory factory; factory.add<Foo>(fooType); factory.add<Bar>(barType); factory.add<MaskedFoo>(maskedType); checkType(factory, fooType); checkType(factory, barType); checkType(factory, maskedType); checkType(factory, unknownType); return 0; }

आप एक उदाहरण के साथ बिटबकेट के साथ एक पैटर्न भी ले सकते हैं, इसके अलावा वहां कई अन्य उपयोगी कक्षाएं हैं।

वह सब है। अच्छा और रचनात्मक कोडिंग!

संदर्भ

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

ऑब्जेक्ट को स्ट्रीम, ऑब्जेक्ट फ़ैक्टरी पैटर्न पर रखें

एक विशिष्ट कारखाने का निर्माण

एक टेम्पलेट फैक्टरी बनाना

कारखाना व्यवहार सेट करने की क्षमता जोड़ें

लिस्टिंग

संदर्भ

More articles: