मैं जाने के लिए नया हूं और मैं सी-स्टाइल स्टैक-आधारित प्रोग्रामिंग के बीच थोड़ा सा कॉन्सेप्टिव असंगति का अनुभव कर रहा हूं, जहां ढेर पर स्वचालित चर रहते हैं और ढेर और पाइथन-स्टाइल स्टैक-आधारित-प्रोग्रामिंग पर आवंटित मेमोरी रहती है। केवल एक चीज जो स्टैक पर रहती है वह है ढेर पर मौजूद वस्तुओं के संदर्भ / संकेत।
जहाँ तक मैं बता सकता हूँ, निम्नलिखित दो कार्य समान आउटपुट देते हैं:
func myFunction() (*MyStructType, error) {
var chunk *MyStructType = new(HeaderChunk)
...
return chunk, nil
}
func myFunction() (*MyStructType, error) {
var chunk MyStructType
...
return &chunk, nil
}यानी एक नई संरचना आवंटित करें और उसे वापस लौटाएं।
अगर मैंने लिखा है कि सी में, पहले एक ने ढेर पर एक वस्तु रखी होगी और दूसरी ने उसे ढेर पर रखा होगा। पहला ढेर के लिए एक पॉइंटर लौटाएगा, दूसरा एक पॉइंटर को स्टैक पर लौटाएगा, जो कि फ़ंक्शन के वापस आने तक वाष्पित हो जाएगा, जो एक बैड थिंग होगा।
अगर मैंने इसे पायथन (या C # को छोड़कर कई अन्य आधुनिक भाषाओं में लिखा) उदाहरण 2 संभव नहीं होता।
मुझे लगता है कि गो कचरा दोनों मूल्यों को इकट्ठा करता है, इसलिए उपरोक्त दोनों रूप ठीक हैं।
उद्धरण के लिए:
ध्यान दें कि, सी के विपरीत, स्थानीय चर का पता वापस करने के लिए यह पूरी तरह से ठीक है; वेरिएबल से जुड़ा स्टोरेज फंक्शन के वापस आने के बाद बच जाता है। वास्तव में, एक समग्र शाब्दिक का पता लेने से प्रत्येक बार मूल्यांकन किए जाने पर एक ताजा उदाहरण आवंटित होता है, इसलिए हम इन अंतिम दो पंक्तियों को जोड़ सकते हैं।
लेकिन यह कुछ सवालों को उठाता है।
1 - उदाहरण 1 में, संरचना ढेर पर घोषित की गई है। उदाहरण 2 के बारे में क्या? क्या इसे स्टैक पर उसी तरह से घोषित किया जाता है जैसे यह C में होता है या यह ढेर पर भी जाता है?
2 - यदि उदाहरण 2 को स्टैक पर घोषित किया जाता है, तो फ़ंक्शन रिटर्न के बाद यह कैसे उपलब्ध रहता है?
3 - यदि उदाहरण 2 वास्तव में ढेर पर घोषित किया गया है, तो यह कैसे है कि संदर्भ के बजाय मूल्य द्वारा संरचनाएं पारित की जाती हैं? इस मामले में संकेत देने वाली बात क्या है?