लूप में पसंदीदा स्थिति कौन सा है?

Question

int n = 5; 
for(int i = 0;i!=n;i++)//condition != 
{ 
//executing 5times 
} 

int n = 5; 
for(int i = 0;i<n;i++)//condition < 
{ 
//executing 5times 

} 

कौन सा पसंदीदा है?

इस से उदाहरण था "त्वरित सी ++ :। उदाहरण के द्वारा व्यावहारिक प्रोग्रामिंग/ एंड्रयू कोएनिग, बारबरा ई मू" बस क्यों लेखक पसंद पहले एक

Answer 1

दूसरा। दो कारणों से

1. से कम (या कभी कभी < =) के लिए हमेशा की तरह है कि ज्यादातर सांकेतिक शब्दों में बदलनेवाला इन लिखना है, और यह यदि संभव हो तो सम्मेलन से चिपक बेहतर है - = शायद कर देगा सबसे कोडर दो बार करने के लिए लग रही है जांच करें कि लूप में कुछ अजीब है जबकि < तुरंत समझा जाएगा।

2. द! = एक सटीक स्थिति पर निर्भर करता है। यदि लूप के इंटीरियर को रखरखाव के दौरान संशोधित किया गया है और मैं गलती से लूप के अंदर बढ़ी है तो आप एक अनंत लूप के साथ समाप्त हो जाएंगे। आम तौर पर आपकी समाप्ति स्थिति को यथासंभव व्यापक बनाना बेहतर होता है - यह बस अधिक मजबूत है।

2 निश्चित रूप से कारण है कि 1.

Answer 2

<n सबसे अधिक इस्तेमाल किया (मेरी राय)

Answer 3

मैं नहीं देख सकते हैं यह मायने रखता है कि, और अधिक महत्वपूर्ण बातों में चिंता करने की नहीं हैं जानना चाहता था के बारे में?

मैं हमेशा बाद वाले का उपयोग करता हूं, और यही मैंने सबसे ज्यादा देखा है।

किसी ने हालांकि इस पर मुझे नीचे गोली मार करने के लिए सुनिश्चित है ....

Answer 4

मैं < कहेंगे के रूप में यह स्थिति की एक व्यापक सेट कैप्चर करता है। मान लीजिए कि एन स्थिर नहीं था लेकिन एक समारोह से लौटा जो दुर्लभ मौकों पर लौटा -1। उस घटना में, लूप के! = संस्करण के साथ, आपके पास बहुत अधिक लूप होगा (जब तक int-a value के आसपास int लपेटता है!)।

Answer 5

condition < का उपयोग करना है क्योंकि यह आपके प्रहरी मूल्य से अधिक कदम और अनंत लूप में गिरने की संभावना कम कर देता है ज्यादा बेहतर है।

Answer 6

मैं आमतौर पर < का उपयोग करके दूसरा तरीका करता हूं। लेकिन उपयोग करने की सोच! = चूंकि C++ में stl iterators इस तरह से काम करता है।

Answer 7

दूसरा। यह हमेशा किसी बिंदु पर पूरा होगा (मान लीजिए कि आप पाश के अंदर काउंटर के मूल्य के साथ खेलने जैसा कुछ मजेदार नहीं कर रहे हैं)।

मैंने कभी भी पहले इस्तेमाल नहीं किया है, कम से कम, इस तरह से नहीं।

Answer 8

जैसा कि प्रश्न में दिया गया है, दोनों लूप समकक्ष हैं। वास्तविक कोड में, हालांकि, यह सामान्य है कि चीजें थोड़ा अधिक जटिल हैं, और उस स्थिति में, "i < n" स्थिति थोड़ी अधिक सुरक्षित होती है। यदि, उदाहरण के लिए, मैं एक से अधिक से बढ़ सकता हूं, तो यह पिछले एन हो सकता है और फिर "i! = N" संस्करण का परिणाम शाश्वत पाश हो जाएगा।

यह रक्षात्मक प्रोग्रामिंग का मामला है।यह सार्वभौमिक रूप से स्वीकार नहीं किया जाता है: कुछ लोग यह सुनिश्चित करना पसंद करते हैं कि चीजें यथासंभव शानदार रूप से विफल हो जाएं ताकि बग जल्दी मिल जाए। रक्षात्मक शैली उस तरह की छोटी समस्याओं को छिपा सकती है।

int n = 5; 
int i = 0; 
while (i != n) { 
    int old_i = i; 
    // the real stuff of the loop here 
    ++i; 
    assert(i == old_i + 1); 
} 

(या, और भी बेहतर, एक भाषा के देशी रूप पूर्व और बाद की स्थिति और पाश अपरिवर्तनशीलताओं निर्दिष्ट करने के लिए synxtax का समर्थन करता है कि का उपयोग करें: हालांकि, अगर आप सभी बग को पकड़ने के लिए चाहते हैं, आप के साथ-साथ सभी तरह से जा सकते हैं ।)

एंड्रयू कोएनिग द्वारा "सी जाल और Pitfalls" पुस्तक (शुरुआत के लिए http://en.wikipedia.org/wiki/C_Traps_and_Pitfalls देखें) यदि आप इस तरह के प्रश्न पर विचार करना चाहते हैं तो शायद आपके लिए दिलचस्प है।

Answer 9

"i < n" बेहतर है। क्योंकि यदि आप "i! = N" का उपयोग करते हैं और कुछ मामलों में आपका प्रारंभिक मैं n से बड़ा है, तो आप एक अनंत लूप दर्ज करेंगे।

Answer 10

मेरा मानना ​​है कि यह एक बेहतर विकल्प है यदि आप गति के लिए अनुकूलित कर रहे:

int n = 5; 
for(int i = n;i > 0;i--) 
{ 
//executing 5times 
} 

उस के लिए कारण यह है कि 0 के साथ तुलना में तेजी है।

Answer 11

मैं < का उपयोग करना पसंद करूंगा, क्योंकि केवल कोड को देखकर आप इसे एक बढ़ते लूप को बता सकते हैं, यह इस तथ्य का समर्थन करता है कि आप i ++ का उपयोग कर रहे हैं।

यदि आप i ++ और < का उपयोग कर रहे हैं और किसी कारण से (अन्य कोडर, टाइपो, मानव गलती) आपके कोड में वृद्धि में वृद्धि होती है - तो आप तुरंत जान लेंगे कि लूप का मूल्यांकन नहीं किया जा रहा है! = यह डीबग करने के लिए इसे कम करने के लिए किसी भी तरह से काम करेगा।

Answer 12

मैं कहता हूं कि यह इटरेटर चर के प्रकार पर निर्भर करता है। यदि आप जानते हैं कि यह एक पूर्णांक है, मैं, दूसरी का प्रयोग करेंगे क्योंकि आप जब तक मैं छोटे n

जो मुझे लगता है अधिकांश के लिए पढ़ने में आसान है की तुलना में है कह सकते हैं

लूप, खुद सहित प्रोग्रामर। यदि आप इटरेटर वैरिएबल के प्रकार को नहीं जानते हैं, तो आपको अपनी क्षमताओं के बारे में कम से कम अनुमान लगाना चाहिए। operator<i के लिए उपलब्ध नहीं हो सकता है: यदि यह यादृच्छिक अभिगम इटरेटर के अलावा कोई भी इटरेटर है, तो operator< उपलब्ध होने की गारंटी नहीं है। इस मामले में मैं operator!= का उपयोग करूंगा।

मैं विकल्प < विकल्प चुनने से बचूंगा क्योंकि आप गलती से अंत मूल्य "कदम" कर सकते हैं। मुझे लगता है कि तर्क त्रुटिपूर्ण है। क्योंकि यदि आपने गलती से कदम उठाया है, तो यह एक बग है और इसे जल्द से जल्द देखा जाना चाहिए (Fail-fast)।