सी ++: स्थानीय सरणी परिभाषा बनाम एक मॉलोक कॉल

Question

इसके बीच क्या अंतर है:

somefunction() { 
    ... 
    char *output; 
    output = (char *) malloc((len * 2) + 1); 
    ... 
} 

और यह:

somefunction() { 
    ... 
    char output[(len * 2) + 1]; 
    ... 
} 

एक दूसरे से अधिक उचित कब होता है?

सभी आपके उत्तरों के लिए धन्यवाद। यहां सारांश है:

1. ex। 1 ढेर आवंटन
2. पूर्व है। 2 स्टैक आवंटन
3. स्टैक पर एक आकार सीमा है, इसे छोटे आवंटन के लिए उपयोग करें
4. आपको ढेर आवंटन मुक्त करना होगा, या यह
5. को रिसाव करेगा, फ़ंक्शन आवंटित होने पर स्टैक आवंटन पहुंच योग्य नहीं होगा
6. ढेर आवंटन तब तक पहुंच योग्य है जब तक आप इसे मुक्त नहीं करते (या ऐप समाप्त होता है)
7. वीएलए मानक सी ++

सुधार का हिस्सा नहीं है।

यहां ढेर बनाम स्टैक के बीच अंतर का कुछ स्पष्टीकरण है:
What and where are the stack and heap?

Answer 1

स्थानीय लोगों का उपयोग करें जब आपके पास केवल थोड़ी सी मात्रा हो, और आप उस फ़ंक्शन के दायरे के बाहर डेटा का उपयोग नहीं करेंगे, जिसे आपने घोषित किया है। यदि आप डेटा को पास करने जा रहे हैं, तो malloc।

स्थानीय चर ढेर पर आयोजित किए जाते हैं, जो ढेर से अधिक आकार सीमित है, जहां मॉलोक के साथ आवंटित सरणी जाती है। मैं आमतौर पर कुछ भी के लिए जाता हूं> ढेर पर 16 बाइट लगाए जाते हैं, लेकिन आपके पास इससे थोड़ा अधिक लचीलापन होता है। बस केबी/एमबी आकार सीमा में स्थानीय आवंटित न करें - वे ढेर पर हैं।

Answer 2

ढेर पर पहले आबंटित करता स्मृति:

यहां ढेर बनाम ढेर के बीच अंतर के कुछ व्याख्या है। आपको स्मृति को मुक्त करना याद रखना होगा, या यह रिसाव होगा। यह उचित है अगर स्मृति को फ़ंक्शन के बाहर उपयोग करने की आवश्यकता है, या यदि आपको बड़ी मात्रा में स्मृति आवंटित करने की आवश्यकता है।

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

Answer 3

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

इस प्रश्न में कोड के साथ कई अन्य अजीब चीजें भी चल रही हैं। सबसे पहले, यह इस एक C++ कार्यक्रम है, आप() ताकि आप कहेंगे

output = new char[len+1]; 

और क्या लेन * 2 + 1 वैसे भी साथ है malloc के बजाय नया प्रयोग करना चाहते हैं?हो सकता है कि यह आपके कोड में कुछ खास है, लेकिन मुझे लगता है कि आप यूनिकोड वर्ण या मल्टीबाइट वर्ण आवंटित करना चाहते हैं। यदि यह यूनिकोड है, तो शून्य समाप्ति दो बाइट्स के साथ-साथ प्रत्येक वर्ण करता है, और चार गलत प्रकार है, जो अधिकांश कंपाइलरों में 8 बिट बाइट्स होता है। यदि यह मल्टीबाइट है, तो हे, सभी दांव बंद हैं।

Answer 4

पहले कुछ शब्दावली:

• पहला नमूना ढेर आवंटन कहा जाता है।
• दूसरा नमूना स्टैक आवंटन कहा जाता है।

सामान्य नियम है:, ढेर पर आवंटित जब तक:

1. सरणी के लिए आवश्यक आकार संकलन समय पर अज्ञात है।
2. आवश्यक आकार कुल स्टैक आकार का 10% से अधिक है। विंडोज और लिनक्स पर डिफ़ॉल्ट स्टैक आकार आमतौर पर 1 या 2 एमबी होता है। तो आपकी स्थानीय सरणी 100,000 बाइट से अधिक नहीं होनी चाहिए।

Answer 5

आपने सी ++ और सी दोनों के साथ अपना प्रश्न टैग किया है, लेकिन सी ++ में दूसरे समाधान की अनुमति नहीं है। परिवर्तनीय लंबाई सरणी केवल सी (99) में ही अनुमति दी जाती है।

यदि आपको लगता है कि 'लेन' स्थिर है, तो दोनों काम करेंगे।

malloc() (और सी ++ 'नया') ढेर पर स्मृति आवंटित करता है, जिसका अर्थ है कि आपको मुक्त() (या यदि आप 'नया', 'हटाएं') बफर, या स्मृति के साथ आवंटित करना है कभी पुनः दावा नहीं किया जाएगा (रिसाव)।

उत्तरार्द्ध स्टैक पर सरणी आवंटित करता है, और जब यह दायरे से बाहर हो जाता है तो चला जाएगा। इसका मतलब है कि आप पॉइंटर्स को उस आवंटन के बाहर बफर में वापस नहीं कर सकते हैं, जिसमें आवंटित किया गया है।

पूर्व उपयोगी है जब आप स्मृति के ब्लॉक को पास करना चाहते हैं (लेकिन सी ++ में, यह आरएआईआई कक्षा के साथ सबसे अच्छा प्रबंधित होता है, मैन्युअल रूप से नहीं), जबकि उत्तरार्द्ध छोटे, निश्चित आकार के सरणी के लिए सबसे अच्छा है जो केवल एक गुंजाइश में मौजूद होना चाहिए।

static char output[(len * 2) + 1]; 

इस के बाहर बफर की ओर इशारा वापस जाने के लिए सक्षम बनाता है:

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

आखिरकार, सी ++ में मॉलोक का उपयोग न करें जब तक कि आपके पास वास्तव में कोई अच्छा कारण नहीं है (यानी, realloc)। इसके बजाए 'नया' और साथ ही 'हटाएं' का प्रयोग करें।