क्यों एक समारोह में malloc स्मृति और बाहर इसे मुक्त एक बुरा विचार है?

Question

यदि यह एक बुरा विचार है, तो फ़ंक्शन में स्मृति आवंटित कैसे करें?

Answer 1

यह "बुरा विचार" नहीं है, बल्कि "कभी-कभी एक बुरा विचार" है, जिसे प्रोग्रामिंग में कई विचारों के बारे में कहा जा सकता है।

फ़ंक्शन के अंदर मेमोरी आवंटित करना और इसे बाहर छोड़ना, एक सामान्य डिजाइन पैटर्न हो सकता है। पर विचार करें:

// hashtable is a typedef-ed pointer type 
hashtable ht = hashtable_new(); 
// .. do something with hashtable 
hashtable_free(ht); 

ht एक समारोह hashtable_new में आवंटित करने और इसे बाहर जारी किया गया था, फिर भी आप अच्छी सी कोड के बहुत सारे में अधिक से अधिक इस पैटर्न देखेंगे।

यह दिखाता है कि, लॉजिकल यूनिट (हैश-टेबल एडीटी) आवंटन और डी-आवंटन का ख्याल रखता है। यह बहुत समझ में आता है - क्योंकि जो जानता है कि कैसे आवंटित किया जाए, जानता है कि कैसे डिलीकेट करना है। विभिन्न लॉजिकल इकाइयों में आवंटित और रिलीज अधिक बार एक बुरा विचार है।

Answer 2

किसी फ़ंक्शन में स्मृति आवंटित करना आवश्यक नहीं है। आपको बस इसे उचित तरीके से साफ करना होगा।

समस्या यह है कि जब आप फ़ंक्शन स्कोप छोड़ देते हैं तो आप ऐसा करने की क्षमता खो सकते हैं।

बस अपने डिज़ाइन से सावधान रहें। हर समय मुफ्त में मॉलोक से मिलान करें और आपके पास मेमोरी लीक नहीं होगा।

Answer 3

यह सवाल सबसे आसान अगर हम इसे रिवर्स जवाब देने के लिए है: कि एक ही समारोह में

• यह एक अच्छा विचार क्यों हो सकता है अगर हर वस्तु malloc 'एक समारोह में d है भी free घ?

जवाब है, कोई मेमोरी लीक या झूलने संकेत हो जाएगा, और इस मूल्यवान परिणाम किसी अन्य समारोह के सहयोग के बिना हासिल की है। नतीजतन, कोड को सही करना आसान है, और फ़ंक्शन में एक साधारण इंटरफ़ेस है।

अब, यदि कोई फ़ंक्शन malloc पर कॉल करता है लेकिन free नहीं है? फिर इस बारे में नियम होना चाहिए कि स्मृति को मुक्त करने के लिए कौन बाध्य है, जब इसे करने की अनुमति है, और जब यह आवश्यक है। ये नियम फ़ंक्शन के इंटरफ़ेस का हिस्सा बन जाते हैं, और फ़ंक्शन को कॉल करने वाले किसी भी व्यक्ति को या तो यह सुनिश्चित करना चाहिए कि नियम या उसके बाद, या संभवतः पर कॉलर (ओं) पर समान नियम लागू करें। स्पष्ट स्मृति प्रबंधन इंटरफ़ेस को जटिलता जोड़ता है, और इंटरफ़ेस जितना अधिक जटिल होता है, उतना आसान है कि एक गलती करना जिससे स्मृति त्रुटि — और सी में हो, तो स्मृति त्रुटि आपके प्रोग्राम को क्रैश कर सकती है।

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

(सरल मामलों में से एक जब एक वस्तु रन टाइम पर आवंटित किया जाता है है, लेकिन हमेशा के लिए जीना अनुमति दी है। लेकिन आप इस तरह की वस्तुओं की संख्या बाध्य करना होगा अन्यथा आप स्थान शेष नहीं होगा।)

Answer 4

यह बुरा विचार नहीं है अगर आप इसे अपनी शैली में लगातार रखते हैं।

एक अच्छा तरीका कॉलर को आवंटित स्मृति को पारित करना है जो इसे पूरा होने पर इसे मुक्त कर सकता है। कुछ इस तरह:

int my_new(char **obj) { 
    *obj = malloc(somesize); 
} 

और उसके बाद इस तरह अपने कार्य से इस फोन:

char *obj; 

my_new(&obj); 

/* work on obj */ 

free(obj) 

संपादित करें: my_new() वापसी int बनाया है। डबल संकेत के लिए कोई ज़रूरत नहीं अन्यथा

Answer 5

निश्चित पैटर्न स्मृति का प्रबंधन करने

1. समारोह के अंदर स्मृति को आबंटित, बाहर यह मुक्त जब यह कारण समय से अधिक जीवित
2. जगह में सूचक धारण करने के लिए करने के लिए कर रहे हैं जब समारोह में मॉलोक संभवतः होता है, और इसे समाप्त होने के बाद इसे हटा दें, जैसा कि जोवे ने कहा था। दिमाग में स्थिरता नियम रखने के लिए, या अन्यथा यह आसानी से स्मृति रिसाव या लटकने वाले पॉइंटर्स का कारण बन जाएगा।