इस सी ++ स्टैक आवंटक के लिए सुधार?

Question

मेरे स्टैक आधारित आवंटक के लिए कोई सुझाव? (सिवाय सुझाव निजी/सार्वजनिक सदस्यों के साथ एक वर्ग का उपयोग करने के लिए)

struct Heap 
{ 
    void* heap_start; 
    void* heap_end; 
    size_t max_end; 

    Heap(size_t size) 
    { 
     heap_start = malloc(size); 
     heap_end = heap_start; 
     max_end = size + (size_t) heap_start; 
    } 

    ~Heap() 
    { 
     ::free(heap_start); 
    } 

    void* allocate(size_t bytes) 
    { 

     size_t new_end = ((size_t) heap_end) + bytes; 

     if(new_end > max_end) 
      throw std::bad_alloc(); 

     void* output = heap_end; 
     heap_end = (void*) new_end; 
     return output; 
    } 

} 

Answer 1

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

Here's one आप एक गाइड के रूप में उपयोग कर सकते हैं। यह आपके जैसा ही है, लेकिन आवंटित नोड्स पर मूल इटरेटर्स शामिल है, और टेम्पलेट्स को जागरूक करने के लिए उपयोग करता है।

Answer 2

दो स्पष्ट समस्याओं:

1/तुम एक deallocate() जरूरत नहीं है।

2/ए deallocate() आपकी वर्तमान रणनीति के साथ लिखना बहुत कठिन होगा जबतक कि आप हमेशा आवंटित करने के सटीक रिवर्स ऑर्डर में डिलीकेट नहीं करेंगे। आपको उस मामले को पूरा करने की आवश्यकता होगी जहां कोई ग्राहक आपके उपयोग किए गए अनुभाग के बीच में स्मृति को हटाना चाहता है।

बेशक, यदि आप रिवर्स ऑर्डर में डिलीकेट करते हैं, (2) कोई समस्या नहीं है। और यदि आप कभी भी स्मृति मुक्त नहीं करते हैं, (1) भी कोई समस्या नहीं है।

यह इस बात पर निर्भर करता है कि आप क्या करना चाहते हैं।

Answer 3

आपका ढेर डीलोकेशन की अनुमति नहीं देता है। सी ++ में नया के साथ आवंटित ऑब्जेक्ट्स के लिए आप इसका उपयोग कैसे करेंगे?

Answer 4

size_t new_end = ((size_t) heap_end) + bytes; 

अच्छा नहीं, कभी नहीं है कि तरह बातें करते हैं, आप को लगता है कि sizeof (size_t) == sizeof (शून्य *), भी क्या हुआ अगर bytes==(size_t)(-1) इस

साथ ही काम नहीं होता है, होता है आपको यह सुनिश्चित करने की ज़रूरत है कि आपके द्वारा वापस आने वाले पॉइंटर्स गठबंधन किए गए हैं। अन्यथा आपको समस्याएं होंगी। इसलिए आपको यह सुनिश्चित करने की ज़रूरत है कि बाइट्स आपके प्लेटफ़ॉर्म के अनुसार 4 या 8 के एकाधिक हैं।

class {... 
char *max_end,*head_end,*heap_start; 
}; 

... 
max_end=heap_start+size; 
... 
bytes=align_to_platform_specific_value(bytes); 
if(max_end-heap_end >= bytes) { 
    void* output = (void*)heap_end; 
    heap_end+=bytes; 
    return output; 
} 
throw std::bad_alloc(); 

सुझाव? पहिया को पुन: पेश न करें। कई और अच्छे पूल पुस्तकालय हैं।