एल-वैल्यू और आर-वैल्यू, स्टैक और हीप

Question

मैं एक हाईस्कूल छात्र जावा (ब्लूजे पर्यावरण में) सीख रहा हूं।

प्रसंग

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

मेरे प्रश्न

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

एल-वैल्यू और आर-वैल्यू का वास्तविक अर्थ क्या है और मेरी पुस्तक का मतलब स्टैक, हेप (मुझे समझने में आसान और आसान समझना चाहिए) और स्मृति की इकाई क्या है। मुझे इस साइट पर ढेर और ढेर से निपटने वाले कई प्रश्न मिले लेकिन वे वहां बहुत ही समझदार नहीं थे क्योंकि वे बहुत तकनीकी थे और इस तरह मेरे पास तकनीकी ज्ञान नहीं है।

Answer 1

1. जब: इसके अलावा मुझे पता है, जहां मैं इस

   यहाँ के बारे में अधिक सीख सकते हैं मेरी पाठ्यपुस्तक से पृष्ठ हैं चाहते हैं शब्द l-value और r-value पहले बनाए गए थे, एल और आर वास्तव में बाएं और दाएं मतलब था। यही है, एल-वैल्यू मूल रूप से बाएं असाइनमेंट के हाथ की तरफ और आर-वैल्यू का मतलब असाइनमेंट का दायां हाथ था। हालांकि, बाद में, उन्हें आपकी पुस्तक के अनुसार क्रमशः 'लोकेटर' और 'रीड' इंगित करने के लिए संशोधित किया गया था। कारण था कि सी जैसे प्रोग्रामिंग भाषाओं में कई ऑपरेटरों (उदा। ऑपरेटर & का पता) है जहां ऑपरेटर के दाएं दाईं ओर दिखाई देने वाला ऑपरेशन अभी भी एक एल-वैल्यू है।

2. stack और heap स्मृति में क्षेत्र हैं। स्टैक का उपयोग स्थानीय चर और फ़ंक्शन कॉल को स्टोर करने के लिए किया जाता है। हीप का उपयोग objects स्टोर करने के लिए किया जाता है। ढेर आपके आवेदन के सभी थ्रेडों द्वारा साझा किया जाता है जबकि स्टैक प्रत्येक थ्रेड को सौंपा गया है।

Answer 2

ढेर और ढेर:

ढेर

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

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

इस क्षेत्र को एक ढेर कहा जाता है क्योंकि प्रोग्राम 1 या तो 1 पर मूल्यों की प्रतिलिपि बनाता है। आप स्थानीय चर या 2 घोषित करते हैं। आप पैरामीटर के साथ फ़ंक्शन कॉल करते हैं।
और फिर यह फ़ंक्शन से लौटने पर पैरामीटर और स्थानीय चर बंद कर देता है।

(इस तरह यह सिद्धांत में काम करता है। प्रैक्टिस में, संकलक इसके बजाय सीपीयू रजिस्टरों को मूल्यों की प्रतिलिपि बनाने के लिए निर्देश लिखेंगे, जहां यह कर सकता है। और वापसी मूल्य भी)।

ढेर

ढेर बस आम तौर पर एक सिस्टम कॉल (linux में brk) (सी में malloc द्वारा कहा जाता है) से, अन्य सभी स्मृति जो इस कार्यक्रम के द्वारा आवंटित किया जाता है को संदर्भित करता है। एक कार्यक्रम में स्मृति के कई भाग हो सकते हैं, जिसने ऑपरेटिंग सिस्टम को आवंटित करने के लिए कहा है। स्मृति के इन हिस्सों (पूरी तरह से) को ढेर कहा जाता है।

जावा में:

• जब आप 'नए' कीवर्ड का उपयोग, यह क्या करता है तुम वापस कुछ स्मृति जो यह ऑपरेटिंग सिस्टम के लिए कहा इसे देने के लिए करने के लिए एक सूचक देना है।

• जब आप एक चर का उपयोग नहीं कर रहे चर का घोषित करते हैं, तो संकलित कोड क्या करेगा, केवल स्टैक मेमोरी एरिया के शीर्ष पर मौजूदा मेमोरी का उपयोग करें, और फिर स्टैक पॉइंटर बदलें।

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

अभ्यास में जावा की तरह एक भाषा जब यह किसी प्रोग्राम को निष्पादित कर रही है, तो एक निश्चित आकार के ढेर के साथ शुरू होता है और ऑपरेटिंग सिस्टम द्वारा पहले से आवंटित स्मृति के एक निश्चित आकार (ढेर कहा जाता है) और केवल तब अधिक स्मृति मांगेगा अंतरिक्ष से बाहर चल रहा है

सीपीयू कैसे काम करते हैं, यह जानने के लिए आपके समय के लायक होंगे, विशेष रूप से उनके पास रेजिस्टर्स हैं जो मूल्यों को संग्रहित करते हैं, और उनमें से एक स्टैक पॉइंटर है। साथ ही वे अतिरिक्त और घटाव कैसे करते हैं।यह महत्वपूर्ण है क्योंकि वे उदाहरण के लिए (आमतौर पर) उदाहरण के लिए नहीं जोड़ते हैं, स्मृति में संदर्भित पते से किसी अन्य संदर्भित पते में किसी संख्या को जोड़ते हैं। यदि आप असेंबली निर्देशों को देखते हैं (जावा बाइट कोड के समान) वे अधिक बार क्या करते हैं:

उदाहरण के लिए एक फ़ंक्शन int addnum (int a, int b) {a + b;} ए। एसपी से संख्या लोड करें यानी जहां एसपी इंगित कर रहा है, रजिस्टर 1

बी। एसपी इंगित करने से पहले संख्या को लोड करें (एसपी -1) रजिस्टर में 0

सी। कॉल सीपीयू निर्देश जोड़ें, जो परिणाम R3 डी में परिणाम संग्रहीत करता है। सपा को R3 मान की कॉपी + 1

कौन सा

इस तरह कॉलिंग कोड दिखाई देंगे: (ध्यान दें, इन उदाहरण सीपीयू निर्देश बने होते हैं - वे एक सीपीयू के लिए अलग हैं और जावा का अपना बाईटकोड है जो है इसी तरह की। मैं सिर्फ उदाहरण के लिए उपयोग कर रहा हूँ STORESP => ढेर लिखते हैं, LOADSP => ढेर सूचक से लोड)

int x; 
x = addnum(9,6); 

INCSP +1 #allocate x at location SP and increment SP by 1 

# start function call 
# make 3 spaces, for a, b, and b and return value 
INCSP +3  #add 3 to SP register 
STORESP 9,0   # copy 9 value to SP-0 
STORESP 6,-1   # copy 6 value to SP-1 

JUMP addnum # jump to executing the function code     

फिर, समारोह ही

LOADSP,0,R1  #copy from SP-0 (a) into reg 1 
LOADSP,-1,R2  #copy from SP-1(b) into reg 2 
ADDREG,R1,R2,R3 # add reg1 reg2 and store in R3 

STORESP,R3,-2  #save the result to SP-2 
RETURN 

फिर समारोह फिर से कॉल: स्टोर एक्स में परिणाम (SP-3 के लिए) (प्रति सपा-2)

LOADSP,-2,R1 
STORESP,R1,-3 

अब समारोह कॉल किया जाता है। तो अंतरिक्ष ए और बी के लिए ढेर और वापसी मान पर आवंटित फेंक

ADDSP -3 

और अब परिणाम (3 से सपा decrementing द्वारा), 'एक्स'

बेशक यह है में है बहुत सरल और सटीक नहीं है लेकिन केवल समझने में मदद के लिए एक उदाहरण के लिए है।

लेकिन यदि आप देख सकते हैं कि इन निम्न स्तर की चीजें कैसे काम करती हैं, तो बस कुछ संख्याओं को जोड़ने की तरह बुनियादी कुछ करने के लिए, तो यह आपको "कहां" और "कैसे" पैरामीटर कार्यों में पारित होने में समझने में मदद करेगा, और वास्तव में महत्वपूर्ण ढेर अवधारणा

गुड लक