C / C ++ में मेमोरी मैनेजमेंट के बारे में

स्टैकओवरफ़्लो पर उन्होंने C ++ अतिरेक के बारे में हालिया पोस्ट के साथ एक प्रतिध्वनित प्रश्न पूछा। C # डेवलपर एरिक लिपर्ट द्वारा एक विस्तारित उत्तर दिया गया था।

प्रश्न:

मेरे पास निम्नलिखित कोड हैं:

int * foo() { int a = 5; return &a; } int main() { int* p = foo(); cout << *p; *p = 8; cout << *p; } 

यह अपवाद और मुद्दों के बिना काम करता है

५ 8

यह कैसे संभव है? एक समारोह के बाहर स्थानीय चर स्मृति सुलभ है?

उत्तर है:
आप एक होटल में एक कमरा किराए पर लेते हैं। आप पुस्तक को रात्रिस्तंभ के शीर्ष दराज में रखते हैं और सो जाते हैं। अगली सुबह आप होटल छोड़ देते हैं, लेकिन आप चाबी देना भूल जाते हैं। तुमने चाबी चुरा ली!

एक हफ्ते बाद, आप होटल में लौटते हैं, चेक इन नहीं करते, चुपके से अपने पुराने कमरे में अपनी चोरी की हुई चाबी से क्रॉल करते हैं और बॉक्स खोलते हैं। आपकी किताब अभी बाकी है। यकीन नहीं होता!

यह कैसे संभव है? क्या कमरा किराए पर लिए बिना नाइटस्टैंड की सामग्री उपलब्ध है?

खैर, यह स्पष्ट है कि यह परिदृश्य वास्तव में बिना किसी समस्या के हो सकता है। ऐसा कोई रहस्यमयी बल नहीं है जो होटल से बाहर निकलते ही किताब को हटा दे। ऐसा कोई रहस्यमयी बल नहीं है जो आपको चोरी की हुई चाबी के साथ एक कमरे में प्रवेश करने से रोके।

होटल को आपकी पुस्तक को साफ करने की आवश्यकता नहीं है । आपने उसके साथ एक अनुबंध पर हस्ताक्षर नहीं किया जो आपके जाने के बाद आपकी पुस्तक को नष्ट करने के लिए उन्हें बाध्य करेगा। यदि आप इसे लेने के लिए चोरी की हुई चाबी के साथ अवैध रूप से अपने कमरे में प्रवेश करते हैं, तो होटल के गार्ड को आपको पकड़ने की आवश्यकता नहीं है । आपने उनके साथ एक अनुबंध पर हस्ताक्षर नहीं किया जो कहता है, "अगर मैं अपने कमरे में जाने की कोशिश करता हूं, तो आपको मुझे रोकना होगा।" लेकिन आपने उनके साथ एक अनुबंध पर हस्ताक्षर किए, जिसमें कहा गया है, "मैं वादा करता हूं कि छुट्टी के बाद अपने कमरे में न जाऊं।" और आपने इस अनुबंध को तोड़ दिया ।

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

आप नहीं जानते कि क्या हो सकता है - जब आपने होटल से बाहर की जाँच की और चाबी चुरा ली ताकि आप इसे बाद में अवैध रूप से उपयोग कर सकें, तो आपने एक पूर्वानुमान और सुरक्षित दुनिया में रहने का अपना अधिकार छोड़ दिया क्योंकि आपने सिस्टम के नियमों को तोड़ने का फैसला किया था ।

C ++ एक सुरक्षित भाषा नहीं है । वह खुशी-खुशी आपको नियम तोड़ने देगा। यदि आप कुछ गैरकानूनी और बेवकूफ बनाने की कोशिश करते हैं, जैसे कि एक कमरे में प्रवेश करना जहां पहुंच से वंचित है, और उन बक्से पर चढ़ना जो वहां नहीं हो सकते हैं, सी ++ आपको रोक नहीं पाएगा। सुरक्षित भाषाएं आपकी क्षमताओं को कम करके इस समस्या को हल करती हैं। उदाहरण के लिए, सख्त कुंजी नियंत्रण।

अद्यतन
हे भगवान, इस जवाब पर बहुत ध्यान जाता है। मुझे लगा कि थोड़ा और तकनीकी बिंदु देना उचित होगा।

कंपाइलर कोड उत्पन्न करने में शामिल होते हैं जो इस कोड द्वारा हेरफेर किए गए डेटा के भंडारण को नियंत्रित करते हैं। स्मृति प्रबंधन के लिए कोड उत्पन्न करने के कई अलग-अलग तरीके हैं, लेकिन वर्षों में दो सरल तरीकों ने जमीन हासिल की है।

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

दूसरा तरीका यह है कि किसी प्रकार की "अल्पकालिक" जगह है जहाँ प्रत्येक बाइट का जीवन समय अच्छी तरह से जाना जाता है, और विशेष रूप से, ऐसे स्थानों का जीवन समय घोंसले के शिकार पैटर्न का अनुसरण करता है। यही है, अल्पकालिक चर के सबसे लंबे समय तक रहने के लिए स्मृति आवंटन स्पष्ट रूप से कम-जीवित लोगों के लिए स्मृति आवंटन को ओवरलैप करता है।

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

इस कारण से, स्थानीय चर आमतौर पर स्टैक पर बनाए जाते हैं, क्योंकि स्टैक में फिल्म की संपत्ति होती है - पहले आओ, आखिरी छोड़ो।

यह ऐसा है जैसे होटल ने कमरों को क्रमिक रूप से किराए पर लेने का फैसला किया है, और आप तब तक चेक आउट नहीं कर सकते, जब तक कि आपके कमरे से बड़े कमरे के सभी मेहमानों की जाँच न हो जाए।

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

हम अस्थायी भंडारण के लिए ढेर का उपयोग करते हैं क्योंकि वे बहुत सस्ते और सरल हैं। स्थानीय चर को संग्रहीत करने के लिए स्टैक का उपयोग करने के लिए C ++ कार्यान्वयन की आवश्यकता नहीं है - यह एक गुच्छा का उपयोग कर सकता है। लेकिन वह ऐसा नहीं करती क्योंकि यह कार्यक्रम को धीमा कर देगा।

C ++ कार्यान्वयन को ढेर पर अपने कचरे को नहीं छूना है ताकि आप अवैध रूप से बाद में वापस आ सकें। यह कंपाइलर के लिए कोड उत्पन्न करने के लिए बिल्कुल कानूनी है, जो आपके द्वारा मुक्त किए गए "कमरे" में सब कुछ रीसेट कर देगा। फिर, वह नहीं करता है, क्योंकि यह एक महंगा ऑपरेशन है।

सी ++ को लागू करने के लिए यह सुनिश्चित करने की आवश्यकता नहीं है कि जब स्टैक को संपीड़ित किया जाता है, तो इसके पुराने पते अभी भी सही मेमोरी पेज को इंगित करते हैं। उसे OS बताने की अनुमति है कि “हम इस पृष्ठ के साथ कर रहे हैं। जब तक मैं अन्यथा नहीं कहता, तब तक एक अपवाद को फेंक दो जो प्रक्रिया को मार देगा यदि कोई इसे छूता है। " फिर, कार्यान्वयन ऐसा नहीं करते हैं क्योंकि यह धीमा और वैकल्पिक है।

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

यह समस्याग्रस्त है। कई नियम हैं और उन्हें गलती से तोड़ना बहुत सरल है। मैंने ऐसा बार-बार किया है। और इससे भी बदतर, ये समस्याएं तब सामने आती हैं जब स्मृति को नैनोसेकंड के अरबों के लिए दूषित कर दिया गया है, और अपराधी को ढूंढना पहले से ही बहुत मुश्किल है।

अधिक स्मृति-सुरक्षित भाषाएँ क्षमताओं को सीमित करके इस समस्या को हल करती हैं। "सामान्य" सी # में, स्थानीय चर का पता लेना और उसे कहीं पर लौटा देना या बाद में उपयोग के लिए सहेजना असंभव है। आप एक चर का पता ले सकते हैं, लेकिन भाषा इतनी चतुराई से डिज़ाइन की गई है कि इसके चर की मृत्यु के बाद इस पते का उपयोग करना असंभव है। पता लेने के लिए और इसे विधि से वापस करने के लिए, आपको संकलक को एक विशेष "असुरक्षित" मोड में रखना होगा और अपने कार्यक्रम में "असुरक्षित" शब्द को शामिल करना होगा ताकि आपको याद दिलाया जा सके कि आप कुछ खतरनाक कर रहे हैं और नियमों को तोड़ सकते हैं।