मजबूत सी प्रोग्राम लिखने के लिए, आप बहुत से अलग मुक्त() संयोजनों से कैसे बचते हैं?

Question

उदाहरण के लिए, मैं स्मृति के दो टुकड़े malloc की जरूरत है, तो:

void *a = malloc (1); 

if (!a) 
    return -1; 

void *b = malloc (1); 

if (!b) 
{ 
    free (a); 
    return -1; 
} 

सूचना यदि दूसरा malloc विफल रहता है, मैं मुक्त करने के लिए "एक" पहले की है। समस्या यह है, यह अगर वहाँ कई ऐसे malloc और त्रुटि जाँच की जब तक कि मैं कुख्यात "गोटो" खंड का उपयोग करें और ध्यान से मुक्त का का क्रम निर्धारित लेबल के साथ कर रहे हैं, बहुत गंदा हो सकता है:

void *a = malloc (1); 

if (!a) 
    goto X; 

void *b = malloc (1); 

if (!b) 
    goto Y; 

return 0; //normal exit 

Y: 
    free (a); 
X: 
    return -1; 

क्या आपके पास इस स्थिति के लिए कोई बेहतर समाधान? अग्रिम में धन्यवाद।

Answer 1

हम इस तरह कार्य करें:

void *a = NULL; 
void *b = NULL; 
void *c = NULL; 
a = malloc(1); 
if (!a) goto errorExit; 
b = malloc(1); 
if (!b) goto errorExit; 
c = malloc(1); 
if (!b) goto errorExit; 

return 0; 
errorExit: 
//free a null pointer is safe. 
free(a); 
free(b); 
free(c); 
return -1; 

Answer 2

मेरी राय में गोटो का उपयोग करना एक बुरी बात नहीं है। संसाधन सफाई के लिए इसका उपयोग करना इसके लिए सही है।

लिनक्स कर्नेल के रूप में प्रसिद्ध स्रोत कोड तकनीक का उपयोग करता है।

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

Answer 3

जैसा कि पहले उल्लेख किया गया था Zan Lynx गोटो स्टेटमेंट का उपयोग करें।

आप आगे के उपयोग के लिए स्मृति के बड़े हिस्से को भी आवंटित कर सकते हैं।

या आप memory pool जैसे कुछ विकसित करने के लिए अपना समय निवेश कर सकते हैं।

Answer 4

या ऐसा करें।

void *a,*b; 
char * p = malloc(2); 
if (!p) return -1; 
a = p; 
b = p+1; 

Answer 5

मुझे लगता है कि OOP तकनीक आप इस समस्या के लिए एक अच्छा और साफ समाधान दे सकता है:

typedef struct { 
    void *a; 
    void *b; 
} MyObj; 

void delete_MyObj(MyObj* obj) 
{ 
    if (obj) { 
     if (obj->a) 
      free(obj->a); 
     if (obj->b) 
      free(obj->b); 
     free(obj); 
    } 
} 

MyObj* new_MyObj() 
{ 
    MyObj* obj = (MyObj*)malloc(sizeof(MyObj)); 
    if (!obj) return NULL; 
    memset(obj, 0, sizeof(MyObj)); 

    obj->a = malloc(1); 
    obj->b = malloc(1); 

    if (!obj->a || !obj->b) { 
     delete_MyObj(obj); 
     return 0; 
    } 

    return obj; 
} 

int main() 
{ 
    MyObj* obj = new_MyObj(); 
    if (obj) { 
     /* use obj */ 
     delete_MyObj(obj); 
    } 
} 

Answer 6

वास्तव में अपने goto कोड के साथ गलत कुछ भी नहीं है आईएमओ (मैं अधिक वर्बोज लेबल का उपयोग करता हूं)।

हालांकि इस मामले में, goto कथन जो आपने लिखा है, उसी तरह की संरचना बनाते हैं जो if s को उलट देता है।

है यही कारण है कि, एक सशर्त आगे goto है कि किसी भी गुंजाइश नहीं छोड़ता नहीं else के साथ एक if बयान के रूप में ठीक उसी करता है। अंतर यह है कि gotoहोता है गुंजाइश छोड़ने के लिए नहीं, जबकि if बाधा छोड़ने के लिए नहीं है। यही कारण है कि if आमतौर पर पढ़ने के लिए आसान है: पाठक के सामने अधिक सुराग है।

void *a = malloc (1); 
if (a) { 
    void *b = malloc (1); 
    if (b) { 
     return 0; //normal exit 
    } 
    free(a); 
} 
return -1; 

स्तरों के एक जोड़े यह ठीक है के लिए, हालांकि बहुत दूर ले जाया आप खरोज की भी कई स्तरों के साथ "तीर कोड" मिलता है। यह पूरी तरह से अलग कारणों से अपठनीय हो जाता है।

Answer 7

बोहेमगैक जैसे कचरा कलेक्टर का उपयोग करें।

यह काम करता है, इसका उपयोग करना आसान है, आम राय के विपरीत कोई मंदी नहीं है।

https://en.wikipedia.org/wiki/Boehm_garbage_collector

http://www.hpl.hp.com/personal/Hans_Boehm/gc/