एक बफर के लिए आकार चुनना

Question

मैं उलझन में हूं, malloc के साथ मेमोरी आवंटित करते समय आपको एक आकार प्रदान करना होगा, हालांकि, कभी-कभी ऐसा होता है कि आपको उस बिंदु पर जिस आकार की आवश्यकता है उसे नहीं पता है ताकि आप या तो एक विशाल आवंटित कर सकें स्मृति की मात्रा (जो बहुत बुद्धिमान नहीं है क्योंकि आप शायद इसका उपयोग नहीं कर रहे हैं) या आप realloc का उपयोग करते हैं जब प्रारंभिक बफर आकार बहुत छोटा हो जाता है। क्या ये दो विकल्प मान्य हैं? दूसरा अच्छा लगता है, हालांकि, दस्तावेज़ कहते हैं कि realloc...may move the memory block to a new location जो स्थिति को संभालने के लिए बहुत बुरे विचार/कड़ी मेहनत की तरह लगता है (उदाहरण के लिए यदि आपके पास realloc पर कॉल करने के पल में एक ही पते पर इंगित करने वाले एकाधिक पॉइंटर्स हैं तो वे सभी अमान्य हो जाते हैं) I ' मैं सी के साथ एक शुरुआत कर रहा हूं, क्या कोई मुझे बता सकता है कि उस परिस्थिति को कैसे संभालना है जिसमें आपके पास एक बफर है जो बहुत सारी स्मृति पर कब्जा करने के लिए बढ़ सकता है या नहीं।

Answer 1

यह कभी कभी होता है कि आप आकार आप उस बिंदु पर की जरूरत है पता नहीं है तो आप या तो alloc स्मृति की एक बड़ी राशि (जो नहीं लग बहुत बुद्धिमान है क्योंकि आप शायद इसका उपयोग नहीं करेंगे सभी) या जब आप प्रारंभिक बफर आकार बहुत छोटा हो जाता है तो आप रीयलोक का उपयोग करते हैं। क्या ये दो विकल्प मान्य हैं?

सिद्धांत रूप में हां। अभ्यास में, आधुनिक ओएस कर्नेल और डिफ़ॉल्ट सिस्टम कॉन्फ़िगरेशन के साथ इससे कोई फर्क नहीं पड़ता कि आप malloc के साथ कितना आवंटित करते हैं। आप देखते हैं, malloc आवंटित पता स्थान, स्मृति नहीं। आप उतना ही पता स्थान आवंटित कर सकते हैं जितना आप चाहते हैं कि यह वास्तव में स्मृति का उपभोग नहीं करेगा; बेशक ओएस मूल्य पर कई सैनिटी चेक लगाएगा, उदाहरण के लिए केवल 2 जीआईबी मेमोरी (रैम + स्वैप) वाली प्रणाली पर आप 3 जीआईबी आवंटित नहीं कर सकते हैं। सामान्य कॉन्फ़िगरेशन यह है कि एक सिंगल खंड में आवंटित पता स्थान का सबसे बड़ा हिस्सा उपलब्ध सिस्टम मेमोरी का 50% है।

केवल जब आप वास्तव में कुछ लिखते हैं, तो ओएस इसके लिए स्मृति आरक्षित करेगा। तो कॉलोक का उपयोग न करें, क्योंकि यह स्मृति को आरंभ करता है, यानी इसमें कुछ लिखना।

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

स्मृति की अतिसंवेदनशीलता के बारे में जागरूक होना एक बात है: कहें कि आपको 4 जीआईबी रैम के साथ एक सिस्टम पर 5 प्रक्रियाएं चल रही हैं, प्रत्येक आवंटन 1 जीआईबी, लेकिन तुरंत इसे लिखना नहीं है। ओएस उन्हें यह पता स्थान देगा, यानी यह स्मृति को कम करता है (जैसे एयरलाइंस ओवरक्विट उड़ान सीटों की तरह)। कुछ समय बाद प्रक्रियाएं इसे लिखना शुरू कर देती हैं। कुछ बिंदु पर सिस्टम स्मृति से बाहर चला जाता है और ओएस को इसके बारे में कुछ करना पड़ता है: जब तक "सांस लेने" के लिए फिर से कमरा न हो जाए तब तक प्रक्रियाओं को मारना शुरू हो जाएगा।

हालांकि आप स्मृति अतिसंवेदनशीलता को बंद कर सकते हैं; उच्च विश्वसनीयता प्रणाली पर दृढ़ता से अनुशंसित।

Answer 2

आप सही हैं - वे आपके दो विकल्प बहुत अधिक हैं। आप थोड़ा सा सारण करके "एकाधिक पॉइंटर्स" समस्या के आसपास काम कर सकते हैं। यदि इसके बजाय सूचक malloc सीधे द्वारा दिया आसपास पास करने का, आप इसे एक और डेटा संरचना में रहना:

struct malloc_wrapper 
{ 
    void *p; 
} wrapper; 

wrapper.p = malloc(INITIAL_SIZE); 

कि डेटा संरचना के बजाय चारों ओर और संकेत गुजरती हैं, आप किसी भी समय p बदल सकते हैं और किसी को भी, जो शेयरों अपने नए संरचना करने के लिए सूचक तदनुसार अपडेट कर दिया जाएगा:

void *tmp = realloc(somepointertowrapper->p, NEW_SIZE); 

/* check tmp to ensure it's not NULL. That indicates a failure 
* to realloc and the original pointer passed into realloc 
* remains valid. 
*/ 

somepointertowrapper->p = tmp;