क्या मैं नए उपयोग किए बिना सी ++ में फैक्टरी विधि पैटर्न को कार्यान्वित कर सकता हूं?

Question

मैं एक एम्बेडेड वातावरण (Arduino/AVR ATMega328) में काम कर रहा हूं और सी ++ में फैक्टरी विधि पैटर्न को कार्यान्वित करना चाहता हूं। हालांकि, मैं जिस कंपाइलर का उपयोग कर रहा हूं (avr-gcc) new कीवर्ड का समर्थन नहीं करता है। new का उपयोग किए बिना इस पैटर्न को लागू करने का कोई तरीका है?

Answer 1

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

void *operator new (size_t size) 
{ 
    return some allocated memory big enough to hold size bytes 
} 

और आप एक साथ ही हटाना निर्धारित करने होंगे: आवंटन

void operator delete (void *memory) 
{ 
    free the memory 
} 

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

Answer 2

क्या आप मॉलोक कर सकते हैं? यदि ऐसा है तो आप अपनी वस्तु को इस तरह से मॉलोक कर सकते हैं।

आपके ऑब्जेक्ट्स की प्रकृति क्या है जिसे आप फैक्ट्री से बनाना चाहते हैं?

• क्या वे अपरिवर्तनीय हैं?
• क्या फैक्ट्री का उद्देश्य केवल वस्तुओं के सीमित सेट का उत्पादन करना है जिसे संकलित समय पर जाना जा सकता है?

यदि उत्तर दोनों प्रश्नों के लिए हाँ है, तो आप स्थिर रूप से अपरिवर्तनीय वस्तुओं के अपने सेट के लिए स्मृति आवंटित कर सकते हैं और फ़ैक्टरी विधि को उचित ऑब्जेक्ट पर लौटने की अनुमति दे सकते हैं।

यदि उत्तर किसी भी प्रश्न के लिए नहीं है तो यह काम नहीं करेगा। इस दृष्टिकोण को भी समझें कि आपको हमेशा उस स्मृति को आवंटित करने की समस्या है।

Answer 3

यदि रनटाइम पर कक्षा को तुरंत चालू करने का कोई तरीका नहीं है, तो मुझे लगता है कि यह संभव नहीं है। आप बस इतना कर सकते हैं कि संकलन समय पर कुछ ऑब्जेक्ट्स को पूर्व-आवंटित करें, उनके लिए संदर्भ बनाएं और आवश्यकता होने पर उन्हें वापस कर दें।

Answer 4

इस तरह कुछ के बारे में क्या?

MyClass *objp = (MyClass*)malloc(sizeof(MyClass)); 
*objp = MyClass(); // or any other c'tor 

संपादित करें: उल्लेख करने के लिए भूल तो वह मान लेता MyClass एक असाइनमेंट ऑपरेटर है।

EDIT2: एक और चीज जिसे मैं भूल गया - हाँ, एक गॉचा है (यह सी ++ है, हमेशा मिलते हैं)। ऑब्जेक्ट के लिए आपको मैन्युअल रूप से डीओ टोर को कॉल करना होगा, क्योंकि आप मुफ्त में उपयोग नहीं कर सकते हैं।

Answer 5

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

Answer 6

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

// Class File --------------------------------------------------- 
class MyObject { 
    public: 
     MyObject* getObject(); 

    private: 
     const int MAX_POSSIBLE_COUNT_OF_OBJECTS = 10; 
     static MyObject allocatedObjects[MAX_POSSIBLE_COUNT_OF_OBJECTS]; 

     static allocatedObjectIndex = 0; 
}; 

// Implementation File ------------------------------------------ 

// Instantiate a static array of your objects. 
static MyObject::allocatedObject[MAX_POSSIBLE_COUNT_OF_OBJECTS]; 

// Your method to return already created objects. 
MyObject* MyObject::getObject() { 

    if (allocatedObjectIndex < (MAX_POSSIBLE_COUNT_OF_OBJECTS - 1)) { 
     return allocatedObjects[allocatedObjectIndex++]; 
    } else { 
     // Log error if possible 
     return NULL; 
    } 
} 

कृपया आगाह किया जाए। यह सब स्मृति से है क्योंकि मैंने 8 महीनों में कोई सी ++ नहीं लिखा है।

यह भी ध्यान दें: इसमें गंभीर कमी है कि आप संकलन समय पर रैम का एक गुच्छा आवंटित कर रहे हैं।

Answer 7

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

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

!! डीन