डिजाइन पैटर्न: सार फैक्टरी बनाम कारखाना विधि

Question

नोट: प्रश्न पोस्ट के अंत में हैं।

मैंने एब्सट्रैक्ट फैक्ट्री बनाम फैक्ट्री मेथड के बारे में अन्य स्टैकओवरफ्लो थ्रेड्स पढ़े हैं । मैं प्रत्येक पैटर्न के इरादे को समझता हूं। हालांकि, मैं परिभाषा पर स्पष्ट नहीं हूं।

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

इसके विपरीत, एब्सट्रैक्ट फैक्ट्री अपने ठोस वर्गों को निर्दिष्ट किए बिना संबंधित या आश्रित वस्तुओं के परिवारों को बनाने के लिए एक इंटरफ़ेस प्रदान करती है।

- जॉन फेमिनाला

सार फैक्टरी बहुत के समान दिखता है फैक्टरी विधि । मैंने अपनी बात को स्पष्ट करने के लिए कुछ यूएमएल कक्षाएं तैयार की हैं।

ध्यान दें:

• आरेख www.yuml.com से हैं इसलिए वे पूरी तरह से उन्मुख नहीं हैं। लेकिन इसकी एक मुफ्त सेवा है :)।
• आरेख सही नहीं हो सकते हैं। मैं अभी भी GoF डिज़ाइन पैटर्न सीख रहा हूँ ।

फैक्टरी विधि:

सार फैक्टरी (केवल 1 सदस्य):

सार फैक्टरी (अधिक सदस्य):

प्रशन:

1. यदि एब्सट्रैक्ट फ़ैक्टरी में केवल एक निर्माता और एक उत्पाद है, तो क्या यह अभी भी एब्सट्रैक्ट फ़ैक्टरी पैटर्न है? (अकाल पैदा करने का एक इंटरफ़ेस)
2. क्या फैक्ट्री मेथड कांक्रीट क्रिएटर इंटरफेस से बनाया जा सकता है या उसे किसी क्लास से होना चाहिए? (कक्षाएं उपवर्गों के लिए तात्कालिकता को टालती हैं)
3. यदि एब्सट्रैक्ट फ़ैक्टरी में केवल एक निर्माता और एक उत्पाद हो सकता है, तो एब्सट्रैक्ट फ़ैक्टरी और फ़ैक्टरी विधि के बीच एकमात्र अंतर है कि पूर्व के लिए निर्माता एक इंटरफ़ेस है और बाद के लिए निर्माता एक वर्ग है?

Comments

नोट: जब मैं इंटरफ़ेस का संदर्भ देता हूं तो मैं जावा इंटरफ़ेस (अमूर्त आभासी तरीकों के साथ सार वर्ग) के संदर्भ में अधिक सोच रहा था। यह स्पष्ट करने के लिए स्वतंत्र महसूस करें कि क्या अलग-अलग भाषाओं में एब्सट्रैक्ट फ़ैक्टरी और फ़ैक्टरी विधि के बीच अंतर मौजूद है।

यहां एक बुनियादी अंतर: stackoverflow.com/questions/1001767 , हालांकि आप जितना पूछ रहे हैं उतना विशिष्ट नहीं है ..

— nawfal

Answer 1

उम्मीद है की यह मदद करेगा। इसमें विभिन्न प्रकार के कारखानों का वर्णन है। मैंने अपने संदर्भ के रूप में हेड फर्स्ट डिज़ाइन पैटर्न का उपयोग किया । मैं आरेख के लिए yuml.me का उपयोग करता था।

स्थैतिक कारखाना

उत्पाद के विभिन्न प्रकार के उत्पाद के लिए एक स्टेटिक विधि के साथ एक वर्ग है।

साधारण फैक्टरी

एक वर्ग है जो विभिन्न प्रकार के उत्पाद का उत्पादन कर सकता है। (यह स्टैटिक फैक्ट्री से बेहतर है। जब नए प्रकार जोड़े जाते हैं तो बेस प्रोडक्ट क्लास को केवल सिंपल फैक्ट्री क्लास में बदलने की आवश्यकता नहीं होती है)

फैक्टरी विधि

इसके प्रकार से संबंधित उत्पाद के एक प्रकार का उत्पादन करने के लिए एक विधि है। (यह एक साधारण फैक्टरी से बेहतर है क्योंकि यह प्रकार एक उप-वर्ग के लिए स्थगित है।)

सार कारखाना

प्रकार के एक परिवार का निर्माण करता है जो संबंधित हैं। यह फैक्ट्री मेथड से भिन्न है क्योंकि इसमें एक प्रकार की एक से अधिक मेथड्स का उत्पादन होता है। (यह बेहतर वास्तविक जीवन के उदाहरण के लिए अगले चित्र के लिए जटिल है)।

.NET फ्रेमवर्क से उदाहरण

DbFactoriesProvider एक सरल कारखाना है क्योंकि इसमें कोई उप-प्रकार नहीं है। DbFactoryProvider एक सार कारखाना है क्योंकि यह विभिन्न संबंधित डेटाबेस ऑब्जेक्ट जैसे कनेक्शन और कमांड ऑब्जेक्ट बना सकता है।

Comments

क्या स्टैटिक फैक्ट्री और सिंपल फैक्ट्री के बीच का अंतर पूरी तरह से है कि क्रिएटप्रोडक्ट पद्धति एक अलग वर्ग में बैठती है?

— पीटर ओ'कालाघन

क्या फैक्ट्री मेथड के मामले में यह स्पष्ट नहीं होगा कि बेटों के रूप में सिर्फ Product(एक सार के रूप में) था, और फिर Product1और Product2? यह इस बात में मदद करेगा कि फैक्ट्री मेथड सिर्फ एक उत्पाद बनाने के बारे में है, जबकि एब्सट्रैक्ट फैक्ट्री कमोबेश फैक्ट्री मेथड का एक समूह है जो परिवारों में एक साथ इकट्ठा होता है।

— lllllll

Answer 2

दो पैटर्न निश्चित रूप से संबंधित हैं!

पैटर्न के बीच अंतर आम तौर पर इरादे में है।

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

आशय का सार फैक्टरी "उनके ठोस वर्ग निर्धारित किए बिना ही संबंधित या निर्भर वस्तुओं के परिवारों बनाने के लिए एक इंटरफेस प्रदान करते हैं।" है

विशुद्ध रूप से इन आशय कथनों (GoF से उद्धृत) के आधार पर, मैं कहूंगा कि वास्तव में फैक्ट्री विधि कुछ इस मायने में है कि एक के एक परिवार के साथ एक "पतित" सार फैक्टरी है ।

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

वे हालांकि कार्यान्वयन में भी संबंधित हैं। जैसा कि GoF पुस्तक में उल्लेख किया गया है,

AbstractFactory केवल उत्पादों को बनाने के लिए एक इंटरफ़ेस की घोषणा करता है। यह वास्तव में उन्हें बनाने के लिए कंक्रीटप्रोडक्ट उपवर्गों पर निर्भर है। ऐसा करने का सबसे आम तरीका प्रत्येक उत्पाद के लिए एक कारखाना विधि को परिभाषित करना है।

इस सी 2 विकी की भी इस विषय पर कुछ दिलचस्प चर्चा है।

Comments

मुझे न तो टिप्पणी समझ में आती है और न ही गिरावट। क्या आप विस्तार से समझा सकते हैं?

— डॉन रॉबी

खैर, जवाब मेरे लिए बयानबाजी लगता है ... कोई वास्तविक concreate उदाहरण ... दायरा बहुत अधिक व्यापक ...

— नोवालिस

Answer 3

ऐसा लगता है कि ओपी की (उत्कृष्ट) सवालों की सूची को नजरअंदाज कर दिया गया है। वर्तमान उत्तर केवल पूर्वाभास की परिभाषा देते हैं। इसलिए मैं मूल प्रश्नों को संक्षिप्त रूप से संबोधित करने का प्रयास करूंगा।

1. यदि एब्सट्रैक्ट फ़ैक्टरी में केवल एक निर्माता और एक उत्पाद है, तो क्या यह अभी भी एब्सट्रैक्ट फ़ैक्टरी पैटर्न है? (अकाल पैदा करने का एक इंटरफ़ेस)

नहीं । एक सार फैक्ट्री को "संबंधित उत्पादों के परिवार" बनाने के लिए एक से अधिक उत्पाद बनाने चाहिए । विहित गोफ उदाहरण बनाता है ScrollBar()और Window()। लाभ (और उद्देश्य) यह है कि एब्सट्रैक्ट फैक्ट्री अपने कई उत्पादों में एक सामान्य विषय को लागू कर सकती है।

2. क्या फैक्ट्री मेथड कांक्रीट क्रिएटर इंटरफेस से बनाया जा सकता है या उसे किसी क्लास से होना चाहिए? (कक्षाएं उपवर्गों के लिए तात्कालिकता को टालती हैं)

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

3. यदि एब्सट्रैक्ट फ़ैक्टरी में केवल एक निर्माता और एक उत्पाद हो सकता है, तो एब्सट्रैक्ट फ़ैक्टरी और फ़ैक्टरी विधि के बीच एकमात्र अंतर है कि पूर्व के लिए निर्माता एक इंटरफ़ेस है और बाद के लिए निर्माता एक वर्ग है?

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

लेकिन इन जवाबों ने एक चौथा सवाल खड़ा कर दिया है!

4. चूंकि, केवल एक विधि के साथ एक इंटरफ़ेस एक फैक्ट्री विधि नहीं हो सकती है, क्योंकि यह एक सार फैक्टरी हो सकती है , जिसे हम केवल एक विधि के साथ एक रचनात्मक इंटरफ़ेस कहते हैं?

यदि विधि स्थिर है, तो इसे आमतौर पर स्टेटिक फैक्टरी कहा जाता है । यदि विधि गैर-स्थिर है, तो इसे आमतौर पर एक साधारण कारखाना कहा जाता है । इनमें से कोई भी एक GOF पैटर्न नहीं है, लेकिन व्यवहार में वे अधिक सामान्यतः उपयोग किए जाते हैं!

Comments

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

— जार्जाल्ड

@Foraldc, GoF (पृष्ठ 107) से " फैक्ट्री मेथड उपवर्गों के लिए एक क्लास डिफरेंस को टालता है । " दूसरे शब्दों में, फैक्ट्री मेथड परिभाषा द्वारा विरासत का उपयोग करता है।

— jaco0646

Answer 4

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

आइए परिभाषाओं को दोहराएं (दोनों विकिपीडिया से)।

सार कारखाना

संबंधित या आश्रित वस्तुओं के परिवारों को उनके ठोस वर्गों को निर्दिष्ट किए बिना बनाने के लिए एक इंटरफ़ेस प्रदान करें ।

फैक्टरी विधि

ऑब्जेक्ट बनाने के लिए एक इंटरफ़ेस को परिभाषित करें , लेकिन इंटरफ़ेस को लागू करने वाली कक्षाओं को यह तय करने दें कि कौन सी क्लास को तत्काल करना है । फैक्टरी विधि उपवर्गों के लिए एक वर्ग आक्षेप को स्थगित करने देती है।

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

एब्सट्रैक्ट फैक्ट्री एक उप-वर्ग में कई अलग-अलग प्रकार के उदाहरण बनाने की अनुमति देती है, और अपनी अलग-अलग उप-कक्षाओं में कृतियों के व्यवहार को विशेष रूप से प्रस्तुत करती है; आम तौर पर, फैक्ट्री विधि केवल एक प्रकार की वस्तु के निर्माण की घोषणा करती है जिसे उप-वर्गीय तंत्र के अनुसार विशेष किया जा सकता है। यही अंतर है।

संक्षेप से। मान लीजिए कि उत्पाद बनाने वाली वस्तुओं के सुपर-क्लास को परिभाषित करता है, और यह कि ProductA और ProductB दो अलग-अलग उप-वर्ग हैं। इसलिए, एब्सट्रैक्ट फैक्ट्री विधि में दो विधियाँ होंगी, createProductA () और createProductB () जो कि इसके विशिष्ट उप-वर्गों में विशेषीकृत (निर्माण चरणों के संदर्भ में) होंगी: फ़ैक्ट्री उप-वर्ग दो भागों वर्गों के लिए निर्माण चरणों को विशेष रूप से निर्दिष्ट करते हैं निर्माण के तहत वस्तुओं की।

उपर्युक्त उदाहरण के अनुसार, फैक्ट्री मेथड को अलग-अलग तरीके से लागू किया जाएगा, ProductA और ProductB के निर्माण को कई फैक्ट्रियों (एक फैक्ट्री प्रति फैक्ट्री) के रूप में, और निर्माण के चरणों के आगे विशेषज्ञता को पदानुक्रम में सौंप दिया जाएगा। ।

Answer 5

अगर मैंने एक एब्स्ट्रैक्टेड (एक इंटरफ़ेस या एब्सट्रैक्ट बेस क्लास के माध्यम से संदर्भित) फैक्ट्री क्लास बनाई है जो ऑब्जेक्ट्स बनाने के लिए केवल एक विधि है, तो यह एक फैक्ट्री मेथड होगा ।

यदि एब्स्ट्रक्टेड फैक्ट्री में ऑब्जेक्ट बनाने के लिए 1 से अधिक विधि थी, तो यह एक एब्सट्रैक्ट फैक्ट्री होगी ।

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

public ActionResult DoSomething(SpecificActionModel model)
{
    var actionModelEngine = manager.GetActionModelEngine<SpecificActionModel>();
    actionModelEngine.Execute(SpecificActionModelEnum.Value);

    var viewModelEngine = manager.GetViewModelEngine<SpecificViewModel>();
    return View(viewModelEngine.GetViewModel(SpecificViewModelEnum.Value);
}

Answer 6

हालाँकि, कई साल हो गए हैं, जब StackOverflow के लोगों ने इस मुद्दे के बारे में इसी तरह के अन्य पदों (सबसे पुराने 2009 में चला जाता है) के बारे में सवाल किया, मुझे अभी भी वह उत्तर नहीं मिला जो मैं चाहता था।

• एब्सट्रैक्ट फ़ैक्टरी पैटर्न और फ़ैक्टरी विधि के बीच अंतर
• फ़ैक्टरी और एब्सट्रैक्ट फ़ैक्टरी पैटर्न के बीच बुनियादी अंतर क्या है?

---

इसलिए मैंने वेब के माध्यम से कुछ घंटों का शोध किया, उदाहरणों की समीक्षा की, और इस निष्कर्ष पर पहुंचे, फैक्टरी विधि से सार फैक्ट्री के प्रमुख अंतर हैं

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

काउंटर उदाहरण होगा

• एक सेडान में इस्तेमाल की जाने वाली स्पोर्ट्स कार के लिए एक कार हिस्सा। इस असंगति से दुर्घटनाएँ हो सकती हैं।
• विभिन्न OS GUI विजेट्स में एक विंडोज-स्टाइल बटन। यह मेरे जैसे कुछ लोगों के लिए कुछ भी नहीं बल्कि उपयोगकर्ता के अनुभव को तोड़ने वाला है।
• बाद में, हमें पता चलता है कि हमारे सॉफ्टवेयर को अगले ओएस अपग्रेड में चलाने की आवश्यकता है, जो कि सॉफ्टवेयर को पीछे की ओर रखते हुए संगत सिस्टम ऑब्जेक्ट के विभिन्न सेट की आवश्यकता है।

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

Answer 7

जहाँ तक मेरा तात्पर्य है ओ सार फैक्ट्री और फैक्ट्री पद्धति की परिभाषाएँ पहले एक को स्थैतिक संदर्भ में लागू किया गया है और इनपुट मापदंडों के आधार पर वस्तु प्रदान करता है।

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

तो यह आमतौर पर दोनों पैटर्नों को एक साथ उपयोग करने की ओर ले जाता है जहां पहले चरण में आप कुछ सामान्य वस्तु बनाते हैं जो संबंधित वस्तुओं के परिवार का वर्णन करता है। इसे स्थैतिक विधि getInstance ("मेरा परिवार का नाम") विधि द्वारा कहा जाता है। इस तरह के getInstance मेथड का कार्यान्वयन यह तय करता है कि कौन सी पारिवारिक वस्तु बनाई जाएगी।

फिर मैं नए बनाए गए पारिवारिक ऑब्जेक्ट पर createProduct () विधि को कॉल करता हूं और पारिवारिक ऑब्जेक्ट के आधार पर नए उत्पाद को वापस कर दिया जाएगा।

ऐसा लगता है कि ये पैटर्न हर एक को सहयोग करते हैं।

दूसरे शब्दों में एब्सट्रैक्ट फैक्ट्री "WHAT" को बनाया जाएगा और फैक्ट्री विधि "HOW" को बनाया जाएगा।

Answer 8

आपको बस इतना याद रखना है कि अमूर्त कारखाना एक कारखाना है जो कई कारखानों को वापस कर सकता है । इसलिए यदि आपके पास एक AnimalSpeciesFactory है तो यह इस तरह से कारखानों को वापस कर सकता है:

मामलफैक्ट्री, बर्डफैक्ट्री, फिशफैक्टिंग, रेप्टाइलफैक्ट्री। अब आपके पास AnimalSpeciesFactory से एक ही कारखाना है, वे विशिष्ट अवरोधों को बनाने के लिए कारखाने के पैटर्न का उपयोग करते हैं। उदाहरण के लिए, कल्पना करें कि आपको इस AnimalFactory से एक सरीसृप मिला है, तो आप साँप, कछुए, छिपकली की वस्तुओं जैसे सरीसृप वस्तुओं को बनाने की पेशकश कर सकते हैं।

Answer 9

/*
//Factory methods:

//1. Factory Method - Abstract Creator Class



#include <iostream>
#include <string.h>
using namespace std;

const std::string nineNintyCC = std::string("990CC");
const std::string thousandTwoHundredCC = std::string("1200CC");
const std::string ThousandFiveHundredCC = std::string("1500CC");
const std::string fiveThousandCC = std::string("5000CC");

// Product
class Engine
{
    public:
    virtual void packEngine() = 0;  
};

// Concrete products
// concrete product class one
class C990CCEngine: public Engine
{

    public:
    void packEngine()
    {
       cout << "Pack 990CC engine" << endl;   
    }
};

// concrete class Two
class C1200CCEngine: public Engine
{   public:
    void packEngine()
    {
        cout << "pack 1200CC engine" << endl;
    }

};

// Concrete class Three
class C1500CCEngine: public Engine
{
    public:
    void packEngine()
    {
        cout << "Pack 1500CC engine" << endl;
    }

};


// Car Factory:
class CarFactory{
    public:

    virtual Engine* createEngine(const std::string& type) = 0;
};
class Factory: public CarFactory
{
    public:
     Engine *createEngine(const std::string& type)
     {

          if(0 == nineNintyCC.compare(type))
          {    
             return new C990CCEngine;
          }
          else if(0 == thousandTwoHundredCC.compare(type))
          {
             return new C1200CCEngine;
          }
          else if(0 == ThousandFiveHundredCC.compare(type))
          {
             return new C1500CCEngine;
          } 
          else
           {
                 cout << "Invalid factory input" << endl;
             return NULL;
           }
           return NULL;
     }
};

int main()
{

    CarFactory* ptr = new Factory;
    Engine*pEngine =  ptr->createEngine(nineNintyCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine =  ptr->createEngine(ThousandFiveHundredCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine =  ptr->createEngine(thousandTwoHundredCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine = ptr-> createEngine(fiveThousandCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    return 0;
}

*/
/*
//
// interface product
#include <iostream>
#include <string>
using namespace std;

class Engine
{
 public:
 virtual void EngineType() = 0;

};

// concrte product
class AltoEngine: public Engine
{
  public:
  void EngineType()
  {
      cout << "Alto Engine" << endl;
  }
};

//Concrte product
class SwiftEngine : public Engine
{
    public:
    void EngineType()
    {
        cout << "Swift Engine" << endl;    
    }
};

class Body
{
   public:
    virtual void bodyType() = 0;

};

class AltoBody: public Body
{
  public:  
    virtual void bodyType()
    {
        cout << "Alto Car Body" << endl;
    }
};

class SwiftBody : public Body
{
    public:
    void bodyType()
    {
        cout << "SwiftCar Body" << endl;
    }

};


class CarFactory
{
   public:
   virtual Engine* createEngineProduct() = 0;
   virtual Body*   createBodyPoduct() = 0;
};
class AltoCarFactory: public CarFactory
{
    public:
    Engine * createEngineProduct()
    {
        return new AltoEngine;
    }
    Body* createBodyPoduct()
    {
        return new AltoBody;
    }

};

class SwiftCarFactory: public CarFactory
{
    public:
    Engine * createEngineProduct()
    {
        return new SwiftEngine;
    }
    Body* createBodyPoduct()
    {
        return new SwiftBody;
    }

};

int main()
{

    CarFactory* pAltoFactory = new AltoCarFactory;
    Engine* pAltoEngine = pAltoFactory->createEngineProduct();
    pAltoEngine->EngineType();
    Body* pAltoBody = pAltoFactory->createBodyPoduct();
    pAltoBody->bodyType();



    CarFactory* pSwiftFactory = NULL;
    pSwiftFactory = new SwiftCarFactory;
    Engine* pSwiftEngine = pSwiftFactory->createEngineProduct();
    pSwiftEngine->EngineType();
    Body* pSwfitBody = pSwiftFactory->createBodyPoduct();
    pSwfitBody->bodyType();
    delete pAltoBody;
    delete pAltoFactory;
    delete pSwfitBody;
    delete pSwiftFactory;
    return 0;
}
*/

/*

// One more Factory example;

#include <iostream>
#include <string>
using namespace std;

const std::string maruthi = std::string("Maruthi");
const std::string fiat = std::string("Fiat");
const std::string renault = std::string("Renault");
// Interface
class CarEngine
{
 public:
    virtual void engineType() = 0;
};

// Concrete class
class FiatEngine: public CarEngine
{
  public:
  void engineType()
  {
      cout << "Fait Engine Engine" << endl;
  }

};
// ConcreteClass
class RenaultEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Renault Engine" << endl;
    }

};
// Concrete class
class MaruthiEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Maruthi Engine" << endl;
    }
};


// Factory
class CarFactory
{
    public:
    virtual CarEngine* createFactory(const std::string&) = 0;
};

// EngineFactory
class CarEngineFactory : public CarFactory
{
     public:
     CarEngine* createFactory(const std::string&  type)
     {
          if(0 == maruthi.compare(type))
          {
              return new MaruthiEngine;

          }
          else if(0 == fiat.compare(type))
          {
              return  new FiatEngine;
          }
          else if(0 == renault.compare(type))
          {
              return new RenaultEngine;
          }
          else
          {
              cout << "Invalid Engine type" << endl;
              return NULL;
          }
     }

  };

int main()
{
    CarFactory* pCarFactory = new CarEngineFactory;
    CarEngine* pMaruthiCarEngine = pCarFactory->createFactory(maruthi);
    pMaruthiCarEngine->engineType();

    CarEngine* pFiatCarEngine = pCarFactory->createFactory(fiat);
    pFiatCarEngine->engineType();


    CarEngine* pRenaultCarEngine = pCarFactory->createFactory(renault);
    pRenaultCarEngine->engineType();

    return 0;
}


*/


/*

// One more Factory example;

#include <iostream>
#include <string>
using namespace std;

const std::string maruthi = std::string("Maruthi");
const std::string fiat = std::string("Fiat");
const std::string renault = std::string("Renault");


// Interface
class CarEngine
{
 public:
    virtual void engineType() = 0;
};

// Concrete class
class FiatEngine: public CarEngine
{
  public:
  void engineType()
  {
      cout << "Fait Car Engine" << endl;
  }

};

// ConcreteClass
class RenaultEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Renault Car Engine" << endl;
    }

};

// Concrete class
class MaruthiEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Maruthi Car Engine" << endl;
    }
};

// Interface
class CarBody
{
 public:
    virtual void bodyType() = 0;
};

// Concrete class
class FiatBody: public CarBody
{
  public:
  void bodyType()
  {
      cout << "Fait car Body" << endl;
  }

};

// ConcreteClass
class RenaultBody : public CarBody
{
    public:
    void bodyType()
    {
        cout << "Renault Body" << endl;
    }

};

// Concrete class
class MaruthiBody : public CarBody
{
    public:
    void bodyType()
    {
        cout << "Maruthi body" << endl;
    }
};


// Factory
class CarFactory
{
    public:
    virtual CarEngine* createCarEngineProduct() = 0;
    virtual CarBody* createCarBodyProduct() = 0;
};

// FiatFactory
class FaitCarFactory : public CarFactory
{
     public:
     CarEngine* createCarEngineProduct()
     {
        return new FiatEngine; 
     }
     CarBody* createCarBodyProduct()
     {
         return new FiatBody;
     }
};

// Maruthi Factory
class MaruthiCarFactory : public CarFactory
{
     public:
     CarEngine* createCarEngineProduct()
     {
         return new MaruthiEngine;
     }
     CarBody* createCarBodyProduct()
     {
         return new MaruthiBody;
     }

};

// Renault Factory
class RenaultCarFactory : public CarFactory
{
     public:
    CarEngine* createCarEngineProduct()
    {
        return new RenaultEngine;
    }

    CarBody* createCarBodyProduct()
    {
        return new RenaultBody;
    }

};


int main()
{

   // Fiat Factory
   CarFactory* pFiatCarFactory = new FaitCarFactory;
   CarEngine* pFiatEngine = pFiatCarFactory->createCarEngineProduct();
   CarBody*  pFiatBody = pFiatCarFactory->createCarBodyProduct();
   pFiatEngine->engineType();
   pFiatBody->bodyType();

   // Renault Car Factory
    return 0;
}

*/

Answer 10

फैक्टरी विधि पैटर्न एक रचनात्मक डिजाइन पैटर्न है जो ऑब्जेक्ट के सटीक वर्ग को दिखाए बिना वस्तुओं को बनाने से संबंधित है जो बनाया जा रहा है। यह डिजाइन पैटर्न मूल रूप से एक वर्ग को उप-वर्गों के लिए तात्कालिकता को खराब करने की अनुमति देता है।

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

गूगल पर खोज करते समय मैं ब्लॉग के बाद आया जिसने दोनों डिजाइन पैटर्न को शानदार ढंग से समझाया। इन पर एक नजर

http://simpletechtalks.com/factory-design-pattern/

http://simpletechtalks.com/abstract-factory-design-pattern/