सी ++ फ्रीिंग स्थिर चर

Question

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

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

क्या ऐसा करने के लिए एक और शानदार तरीका है?

कृपया मुझे बताएं।

धन्यवाद, jbu

Answer 1

आप यहाँ दो समाधान है:

1. हटाना न हटाएँ यह (आप, सही सी में हैं ++, आप नए का उपयोग करें और उन्हें हटाना;?)) । लगभग सभी ओएस आज आवेदन समाप्त होने के बाद भी एप्लिकेशन द्वारा आवंटित स्मृति को "मुक्त" करेंगे। लेकिन यह एक अच्छा समाधान नहीं है, जो उदाहरण के लिए पहचानने के लिए मेमोरी लीक को कठिन बनाता है।
2. अपने पॉइंटर को कक्षा (सदस्य के रूप में) में एकीकृत करें, फिर इस कक्षा का उपयोग अपनी स्थिरता के प्रकार के रूप में करें। इस तरह, आप जानते हैं कि कक्षा के विनाशक को आवेदन के अंत में बुलाया जाएगा। फिर आप विनाशक में अपना डेटा हटा दें और काम पूरा हो गया है और साफ है। वह आरएआईआई की शक्ति है।

मेरा सुझाव है कि आप 2 करते हैं, यह करने के लिए यह वास्तव में एक साफ तरीका है।

---

यहां एक साधारण उदाहरण है। इसके बजाय ऐसा करने से

static Thing* things = new Thing(); // or whatever way to initialize, here or in a specific function 

आप ऐसा करेंगे:

class ThingManager // or whatever name you like 
{ 
public: 
    ThingManager(Thing* thing) : m_thing(thing) { }//or create it here? whatever solution suits your way of creating the data 

    ~ThingManager() { delete m_thing; } // THAT's the important part! 

    Thing* instance() const { return m_thing; } // or whatever accessor you need, if you need one 

private: 
    Thing* m_thing; 
}; 

और फिर

static ManagedThing thing; // now i can access it via thing.instance() 

जब कार्यक्रम समाप्त होता है, स्थिर चर (कि अब और सूचक नहीं है) नष्ट कर दिया जाएगा और यह विनाशक ऐसा करने के लिए बुलाया जाएगा।

यह आपको यह बताने के लिए लिखा गया है कि आप यह कैसे कर सकते हैं।

Answer 2

आप एक स्थिर सूचक के रूप में स्थिर चर घोषित कर सकते हैं, फिर प्रोग्राम आवंटित सूचक को समाप्त कर दिया जाएगा।

Answer 3

मैं ट्रैक करने के लिए कक्षा में एक स्थिर काउंटर परिभाषित करेगा वस्तु उदाहरणों गिनती के रूप में नाशक यह काउंटर और अगर काउंटर == 0 मुक्त स्मृति भी .. बस आप के रूप में

Answer 4

ओएस से घटती निष्पादित मिल परिप्रेक्ष्य में, स्मृति को मुक्त करने में कोई वास्तविक बिंदु नहीं है क्योंकि आपका प्रोग्राम समाप्त हो जाता है, जो कुछ भी धीमा हो जाता है। आपके आवेदन की समाप्ति आपके पूरे पता स्थान को आँसू देती है, यह सब कुछ मुक्त कर देगा, आप एक ही समय में ढेर पर आवंटित करते हैं। स्पष्ट रूप से free को ऐप शट डाउन पर कॉल करने से ढेर में केवल पॉइंटर्स को घुमाया जा रहा है जो किसी भी तरह से फेंक दिया जाएगा।

मुख्य कारण है कि हम स्पष्ट रूप से सब कुछ को मुक्त करने के इतनी मेहनत की कोशिश करें कि हम स्मृति लीक नहीं कर रहे हैं और हमारी स्मृति पदचिह्न हमेशा के लिए नहीं उगता हो रहा है।

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

Answer 5

एक स्मार्ट सूचक में फेंक। यह स्थिर जीवन होगा और main रिटर्न के बाद नष्ट कर दिया जाना:

// static 
void YourClass::freePointer(void) 
{ 
    delete getPointer(); 
} 

// static 
T* YourClass::getPointer(void) 
{ 
    if (!thePointer) 
    { 
     thePointer = new T; 
     atexit(freePointer); 
    } 

    return thePointer; 
} 

कौन सा वैसा ही प्रभाव पड़ेगा:

static std::auto_ptr<T> thePointer; 

एक अन्य विकल्प अपने स्वयं के atexit समारोह रजिस्टर करने के लिए है। एक और विकल्प जिसका आप पहले से उल्लेख करते हैं वह एक स्थिर काउंटर रखना है। ध्यान दें कि आप वास्तव में इसे बहुत प्रभावी ढंग से लपेट सकते हैं।