पर्ल

Question

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

असल में, मैंने लूप के अंदर 'my' कीवर्ड के साथ एक सरणी चर घोषित कर दिया है। मैं फिर इस घोषित सरणी चर के पते का उपयोग किसी अन्य सरणी चर में करता हूं जिसे लूप के लिए उपरोक्त घोषित करने से पहले घोषित किया गया है। एक अलग आकार हर बार

my @Array_of_ALL_Vals; 
for my $iloop (0 .. 10){ 
    my @Array_Vals; 
    . 
    Code in here to populate @Array_of_Vals 
    . 
    push @Array_of_ALL_Vals,\@Array_Vals; 
} 

@Array_Vals चर रहा है, सामान्य रूप में,: बुनियादी कोड संरचना इस तरह दिखता है। इसके अलावा लूप के अंदर परिभाषित सरणी @Array_Vals का उपयोग कोड में कहीं और नहीं किया जाता है और लूप के लिए स्थानीय होता है।

मेरी चिंता लूप के भीतर सरणी की घोषणा के साथ है। भले ही वेरिएबल का नाम समान होता है, हर बार जब मैं मानता हूं कि प्रत्येक लूप पुनरावृत्ति के लिए इसे एक अलग स्मृति पते पर असाइन किया जाता है। क्या ये सही है?

मैंने सोचा कि लूप के अंदर सरणी नाम में वृद्धिकर्ता जोड़ना बेहतर होगा ताकि नाम प्रत्येक बार अलग हो (@ Array_Vals1, @ Array_Vals2, ...)। फिर मैं इन मानों को @Array_of_ALL_Vals सरणी में धक्का दे सकता हूं और सुनिश्चित कर सकता हूं कि अंतिम सरणी मानों को ओवरराइट नहीं किया जाएगा। हालांकि कुछ खोज करने के बाद मैंने पाया कि इस तरह के तरीकों को हतोत्साहित किया गया है (वैरिएबल नाम परिवर्तनीय)।

तो मुझे लगता है कि मैं क्या पूछ रहा हूँ है: प्रत्येक पाश यात्रा के लिए एक ही सरणी नाम का उपयोग कर और फिर एक नई सरणी को यह सरणी के पते जोड़कर (@Array_of_ALL_Vals) मान्य की मेरी विधि है? या, क्या यह तथ्य है कि सभी पुनरावृत्तियों के बाद लूप सरणी (@Array_Vals) ओवरराइट हो रही है, मेरी सरणी @Array_of_ALL_Vals (जिसमें @Array_Vals सरणी के पते शामिल हैं) की वैधता को गड़बड़ कर रहा है?

कोई टिप्पणी

Gauss76

Answer 1

हर बार जब आप अपने पाश में प्रवेश के लिए बहुत धन्यवाद, आप एक नया @Array_Vals बुलाया चर मिलता है। इनमें से प्रत्येक चर स्मृति के एक अलग हिस्से में रहेंगे और इसलिए, एक अलग संदर्भ होगा। आप अपने लूप के अंदर अपने सरणी (print \@Array_Vals) के संदर्भ को प्रिंट करके इसे सत्यापित कर सकते हैं।

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

यदि @Array_of_All_Vals सरणी कभी भी गुंजाइश से बाहर निकलना था, तो पर्ल अपने तत्वों में संग्रहीत सभी संदर्भों पर संदर्भ गणना को कम करेगा। पुरानी @Array_Vals सरणी पर संदर्भ गणना शून्य पर जाएगी और पर्ल का कचरा संग्रह भविष्य में किसी बिंदु पर उस स्मृति को दोबारा उपयोग करने के लिए स्वतंत्र होगा।

तो, आपके द्वारा विकसित तंत्र को ठीक काम करने की गारंटी है। वास्तव में यह इस तरह की स्थितियों के लिए अनुशंसित दृष्टिकोण है।