मैंने नीचे दिए गए 2 तरीकों से लूप के लिए कोड लिखा है:

पहला तरीका

for(int i=0;i<myList.Items.Count;i++)
{
.....
.....
.....
}

दूसरा तरीका

int itemsCount = myList.Items.Count;
for(int i=0;i<itemsCount;i++)
{
.....
.....
.....
}

मेरे विचार में पहला तरीका बेहतर है, भले ही मैं प्रत्येक वेतन वृद्धि इसकी जाँच को महत्व देता हूँ (मैं < myList.Items.Count) क्योंकि रनटाइम पर यह बस myList.Items.Count को memeroy refrence से बदल देता है तो मेरे अनुसार अगर मैंने वस्तुओं की गिनती आवंटित करने के लिए एक नया स्थानीय चर लिया तो यह सिर्फ स्मृति की बर्बादी है।

मैं जानना चाहता हूं कि जब मैं ऊपर जैसा कोड लिखता हूं तो यह कैसे कार्य करता है और मुझे बताएं कि प्रदर्शन पहलू को देखते हुए कौन सा तरीका अधिक बेहतर है

0
Ramakrishna 23 अगस्त 2011, 16:36
अगर कुछ भी यह एक सूक्ष्म अनुकूलन होने जा रहा है, तो इसके बारे में चिंता करने योग्य नहीं है जब तक कि यह वास्तव में आपको कोई समस्या नहीं दे रहा है।
 – 
Evan Trimboli
23 अगस्त 2011, 16:46

1 उत्तर

सबसे बढ़िया उत्तर

मेरा मानना ​​​​है कि कुछ परिस्थितियों में पहला तरीका (कुछ कंपाइलर्स में) अधिक इष्टतम तरीका है।

आप एक भाषा नहीं बताते हैं, लेकिन यह सी # हो सकता है - इसलिए मैं उस कंपाइलर के लिए उत्तर दूंगा। सी # में मेरा मानना ​​​​है कि चलने का पूर्व तरीका तेज़ है क्योंकि यह संकलक को सरणी सीमाओं की जांच करने की अनुमति देता है यदि आप अपने लूप में आइटम्स के सदस्यों तक पहुंच रहे हैं। यदि आप किसी आइटमकाउंट वैरिएबल का उपयोग करते हैं तो कंपाइलर के लिए यह ट्रैक करना अधिक जटिल हो जाता है कि लूप में उपयोग किए गए वेरिएबल का एक सुरक्षित मान है। यह केवल स्थानीय रूप से स्कोप किए गए सरणी के मामले में है।

वह तर्क जावा जैसी अन्य भाषाओं के लिए हो सकता है जो समान दिखने वाले लूप का उपयोग कर सकते हैं।

यहां एक और सवाल है जो संबोधित करता है सी#में फॉर-लूप के साथ यह प्रश्न।

मैं यह भी जोड़ूंगा (प्रश्न पर @Evan की टिप्पणी के बाद) कि इस तरह का अनुकूलन शायद ही कभी आवश्यक है, जब तक कि आपको कोड के तेज़ खंड की विशिष्ट आवश्यकता न हो। पहले लिखें कि सबसे अधिक पठनीय और कम समस्याएं पैदा करने की संभावना क्या है, फिर जहां आवश्यक हो वहां अनुकूलित करें।

0
Community 23 मई 2017, 14:55
आपके उत्तर के लिए धन्यवाद, हां, मैं केवल सी # में कोड लिखा हूं। आपके स्पष्टीकरण में, आपने बताया कि यदि हम आइटमकाउंट वैरिएबल का उपयोग कर रहे हैं तो यह उस वेरिएबल को ट्रैक करने के लिए और अधिक जटिल हो जाता है .. मुझे इसका मतलब समझ में नहीं आया (मेरी समझ के अनुसार हर बार कंपाइलर को उस वेरिएबल "आइटमकाउंट" की जांच करनी चाहिए, इसे संशोधित किया गया है या यहां तक ​​कि इसे संशोधित भी नहीं किया गया है)
 – 
Ramakrishna
23 अगस्त 2011, 17:26
- मूल रूप से संकलक इस बात पर भरोसा कर सकता है कि यदि आप .Count या .Length (सरणी के लिए) के खिलाफ जाँच कर रहे हैं, तो प्रत्येक लूप के लिए चारों ओर जाता है - तो i का मान सूची या सरणी की सीमा से अधिक नहीं हो सकता है - इसलिए सीमा को हटाने के लिए अनुकूलित करता है जाँच कोड। यदि आप कुछ मनमानी चर के खिलाफ जांच कर रहे हैं, तो यह आपके कोड के तर्क की जांच के लिए और कदम उठाए बिना ऐसा नहीं कर सकता है। तो भले ही आपका कोड पूरी तरह से सुरक्षित हो - अनुकूलन नहीं किया जाता है। आपका 'पहला उदाहरण' कंपाइलर के लिए यह जांचना आसान है कि मैं कभी नहीं सूची की सीमा को पार कर सकता हूं।
 – 
iandotkelly
23 अगस्त 2011, 17:51