ढेर: स्टैक का उपयोग वर्तमान में निष्पादित कोड के ब्लॉक द्वारा उपयोग के लिए अस्थायी स्क्रैच पैड के रूप में किया जाता है, और जो भी ब्लॉक वर्तमान प्रवाह कहा जाता है, और जो भी ब्लॉक उसे बुलाया जाता है, और इसी तरह। जब वर्तमान ब्लॉक निकलता है, तो स्थानीय चर जो इसका उपयोग कर रहे थे भूल गए हैं। जैसा कि नाम इंगित करता है, स्टैक का उपयोग अंतिम रूप में, पहले तरीके से किया जाता है।
स्टैक के सबसे महत्वपूर्ण उपयोगों में से एक वर्तमान कॉल श्रृंखला का ट्रैक रखना है। जब एक फ़ंक्शन किसी अन्य को कॉल करता है, तो कॉलर अगले निर्देश (वापसी पता) के पते को स्टैक पर धक्का देता है। चूंकि प्रत्येक फ़ंक्शन निकलता है, यह स्टैक से कॉलर का रिटर्न पता पॉप करता है और उस पते से शुरू होने वाले कोड को निष्पादित करता रहता है। यह फ़ंक्शन पैरामीटर को संप्रेषित करने और कॉलर और कैली के बीच मूल्यों को वापस करने के लिए भी उपयोग किया जाता है।
हीप: ढेर अलग है - इसमें कोई विशेष आदेश नहीं है। यदि आप कोड के ब्लॉक में स्मृति आवंटित करना चाहते हैं और उस मेमोरी को ब्लॉक के अंत से चारों ओर चिपकाना है, तो आप इसे ढेर पर आवंटित करते हैं। बेशक, आपको कहीं भी पॉइंटर/संदर्भ स्टोर करने की आवश्यकता होगी ताकि अन्य कोड उस स्मृति को पा सके; अधिकांश भाषाएं आवास प्रदान करती हैं।
गति: गति में मतभेद स्मृति की किसी भी संपत्ति के कारण नहीं हैं - जैसा कि आप अपने प्रश्न में कहते हैं, दोनों ढेर और ढेर आम तौर पर एक ही भौतिक स्मृति में रहते हैं। स्टैक पर स्थान आवंटित करना ढेर के कारण त्वरित है LIFO प्रकृति: यदि आप स्टैक पर कुछ धक्का देते हैं, तो केवल एक ही स्थान समाप्त हो सकता है। इसके विपरीत, ढेर पर एक ब्लॉक आवंटित करने के लिए स्मृति में एक पर्याप्त पर्याप्त संगत मुक्त क्षेत्र की आवश्यकता होती है। एक स्टैक आवंटन एक ही निर्देश के रूप में जल्दी हो सकता है; एक ढेर आवंटन को malloc() जैसे मेमोरी आवंटन फ़ंक्शन पर कॉल की आवश्यकता होती है।
स्टेटिक वी। गतिशील: ढेर पर स्मृति आवंटित गतिशील है - चाहे ब्लॉक को आवंटित किया जाए, और ब्लॉक का आकार, प्रोग्राम के दौरान प्राप्त होने वाले इनपुट के अनुसार निर्धारित किया जा सकता है। ढेर पर आवंटित स्मृति के क्षेत्र को यदि आवश्यक हो तो भी आकार बदल सकते हैं। यह संभव गतिशील रूप से स्टैक पर स्मृति आवंटित करने के लिए भी है (सी मानक लाइब्रेरी फ़ंक्शन alloca() देखें), लेकिन जैसे ही वर्तमान फ़ंक्शन निकलता है, वह स्मृति खो जाएगी। स्टैक आवंटन आमतौर पर स्थैतिक होते हैं - संकलक निर्धारित करता है कि (गैर-रजिस्टर) पैरामीटर, डेटा लौटाएं और स्थानीय चर के लिए कितनी जगह की आवश्यकता है, और यह फ़ंक्शन कहलाते समय स्टैक पर आवश्यक स्थान को आरक्षित करने के लिए कोड उत्पन्न करता है।
उदाहरण: कल्पना कीजिए कि आप एक वर्ड प्रोसेसर बना रहे हैं। आप समय से पहले नहीं जान सकते कि दस्तावेज़ कितना बड़ा होगा, या यहां तक कि एक ही समय में कितने दस्तावेज़ उपयोग किए जाएंगे। साथ ही, आप चाहते हैं कि उपयोगकर्ता के दस्तावेज़ स्मृति में बने रहें जब तक कि उपयोगकर्ता उन्हें खोलना न चाहें। यदि आप स्टैक पर दस्तावेज़ों के लिए स्मृति आवंटित करने का प्रयास करते हैं तो आपको एक से अधिक बार एक से अधिक खुला होना मुश्किल लगेगा, और आपको एक ऐसा फ़ंक्शन बनाना होगा जो दस्तावेज़ बनाता है, संपादित करता है, सहेजता है और बंद करता है। ढेर पर जगह आवंटित करने से आप जितने चाहें उतने दस्तावेज तैयार कर सकते हैं, प्रत्येक डेटा में जो डेटा शामिल है, उसके लिए उपयुक्त है, और दस्तावेजों के जीवनकाल को किसी भी विशेष कार्य के जीवनकाल में टालने से बचने के लिए।
सारांश: संक्षेप में, ढेर, जबकि ढेर स्मृति कि वर्तमान ब्लॉक से जीवन से परे उपयोग किया जाएगा आवंटित करने के लिए प्रयोग किया जाता है, चरों के मान (कभी कभी रजिस्टरों के बजाय इस्तेमाल किया जाता है) रखती है।
http://stackoverflow.com/questions/7123936/why-is-there-a-stack-and-a-heap – drdwilcox
http://stackoverflow.com/questions/79923/what-and-where-are -the-stack-and-heap –