for लूप का अध्ययन करते समय, हमने कहा कि यदि किसी क्रिया के दोहराव की संख्या ज्ञात है, तो आप for लूप ऑपरेटर का उपयोग करके प्रोग्राम को छोटा कर सकते हैं। और क्या होगा अगर दोहराव की संख्या ज्ञात नहीं है। और ऐसा अक्सर होता है।
उदाहरण के लिए:
दशमलव संख्या प्रणाली से किसी अन्य में किसी संख्या के अनुवाद को याद करते हुए, हमें संख्या प्रणाली के आधार द्वारा संख्या (और फिर विभाजन का परिणाम) को तब तक विभाजित करना होगा जब तक कि हमें उत्तर में शून्य न मिल जाए। हम कितनी बार साझा करेंगे ज्ञात नहीं है। और ऐसे कई प्रोग्राम हैं जो इस तरह के एल्गोरिद्म को लागू करते हैं।
इसे कैसे लागू किया जाता है?
प्रोग्रामिंग में ऐसे मामलों के लिए, एक शर्त के साथ एक लूप ऑपरेटर होता है।
C प्रोग्रामिंग लैंग्वेज में, एक सशर्त लूप स्टेटमेंट शब्द के साथ शुरू होता है और इसकी निम्नलिखित संरचना होती है।
<पूर्व>
<कोड>जबकि (<स्थिति>){
लूप बॉडी
}
जैसा कि हम पहले से ही जानते हैं:
- शर्त एक व्यंजक है, जिसका परिणाम या तो सत्य या असत्य हो सकता है (जैसा कि सशर्त कथन में होता है)
- लूप बॉडी वह कमांड है जिसे दोहराने की जरूरत होती है
- कर्ली ब्रेसिज़ को छोड़ा जा सकता है अगर लूप बॉडी में केवल एक
ऑपरेटर हो
ऑपरेटर कैसे काम करता है:
1. सबसे पहले, कार्यक्रम शब्द के बाद ब्रैकेट में स्थिति का मूल्यांकन करता है। यदि शर्त पूरी होती है (सत्य), तो प्रोग्राम लूप बॉडी में निहित बयानों को निष्पादित करता है।
2. जैसा कि लूप के लिए होता है, अगर लूप बॉडी में केवल एक स्टेटमेंट होता है, तो लूप बॉडी को हाइलाइट करने वाले घुंघराले ब्रेसिज़ को छोड़ा जा सकता है।
3. लूप बॉडी का निष्पादन पूरा होने के बाद, प्रोग्राम स्थिति की जांच करने के लिए वापस आता है और इसे फिर से जांचता है।
4. ये क्रियाएं (स्थिति की जांच - लूप बॉडी को निष्पादित करना) तब तक दोहराई जाती हैं जब तक कि स्थिति झूठी नहीं हो जाती।
5. यदि इस ऑपरेटर के पहले निष्पादन पर, स्थिति तुरंत संतुष्ट नहीं होती है (गलत), तो प्रोग्राम लूप बॉडी को कभी भी निष्पादित नहीं करेगा।
इस ऑपरेटर के काम का विश्लेषण करते हुए, यह स्पष्ट हो जाना चाहिए कि लूप बॉडी में एक ऑपरेटर होना चाहिए जो स्थिति को प्रभावित करता हो।
उदाहरण के लिए, एक लूप किसी स्थिति में उपयोग किए जाने वाले वेरिएबल के मान को बढ़ा सकता है।
प्रोग्राम का एक उदाहरण जिसे हम "साइलेंट काउंट"
कहेंगे
आइए, हमारी बजाय प्रोग्राम की गिनती करें, उदाहरण के लिए, 10 तक।
कार्यक्रम को "प्रारंभ" वाक्यांश को आउटपुट करना चाहिए और "समाप्त", और इन क्रियाओं के बीच उन संख्याओं को प्रदर्शित करते हैं जिनकी गणना की जा रही है।
इस तरह,
शुरू
1 2 3 4 5 6 7 8 9 10
समाप्त
थोड़ी देर के लूप का उपयोग करने वाला प्रोग्राम इस तरह दिखेगा।
<पूर्व>
<कोड>#शामिल<iostream>
नेमस्पेस एसटीडी का उपयोग करना;
मुख्य()
{
int मैं;
cout << "प्रारंभ\n";
मैं = 1;
जबकि(मैं<=10)
{
cout << मैं<<" ";
मैं++; // ऑपरेटर जो स्थिति में चर के परिवर्तन को प्रभावित करता है
}
cout << "\nसमाप्त";
}
इस प्रोग्राम में, हम वेरिएबल i=1 - ओरिजिन
को एक वैल्यू असाइन करते हैं
इसके अलावा, जब तक हमारे पास वेरिएबल i का मान हमारे लिए आवश्यक मान से अधिक नहीं है (अर्थात, इससे कम या इसके बराबर), हम
1 - वेरिएबल i
का मान प्रदर्शित करता है
2 - वेरिएबल i के मान को 1 से बढ़ाएँ - यह ऑपरेटर कोष्ठक में स्थिति के मान को प्रभावित करता है। वेरिएबल i बढ़ा हुआ है, यानी किसी बिंदु पर स्थिति i<=10 झूठी हो जाएगी। यह तब होगा जब i 11 के बराबर हो जाएगा। इस मामले में, लूप बॉडी को निष्पादित नहीं किया जाएगा, और प्रोग्राम लूप के बाद अगला स्टेटमेंट निष्पादित करेगा, अर्थात। कॉउट << "\nसमाप्त";