(सी ++) लूप्स। पैरामीटर के साथ लूप (के लिए)


लूप्स इन प्रोग्रामिंग
एक ऐसी स्थिति की कल्पना करें जहां हमें एक ही शब्द को स्क्रीन पर प्रदर्शित करने की आवश्यकता है, आइए "HELLO" शब्द को 10 बार कहें। हमें क्या करना चाहिए?
आप cout << को 10 बार ले और लिख सकते हैं। "नमस्कार";

लेकिन क्या होगा अगर आपको 10 बार नहीं, बल्कि 20, 30, 40 बार और अगर 200 बार चाहिए? ऐसे में नकल में काफी समय लगेगा। और यदि उपयोगकर्ता के लिए यह चुनना आवश्यक है कि स्क्रीन पर कितनी बार जानकारी प्रदर्शित करनी है? 

इस कार्य से निपटने के लिए, हम लूप
नामक एक विशेष निर्माण का उपयोग करेंगे  
लूपएक एल्गोरिथम निर्माण है जिसमें कमांड का एक निश्चित क्रम कई बार दोहराया जाता है।< /दिवि>
C++ प्रोग्रामिंग लैंग्वेज में, दो प्रकार के लूप होते हैं: एक वेरिएबल लूप (<कोड>के लिए) और एक कंडीशनल लूप (<कोड>जबकि और <कोड> करते हैं...जबकि कोड >)

चलिए पहले प्रकार से साइकिल से परिचित होना शुरू करते हैं।
 
चर के साथ लूप (के लिए)

अक्सर ऐसा होता है कि हम कुछ क्रियाओं की पुनरावृत्ति की संख्या जानते हैं, या हम ज्ञात डेटा का उपयोग करके दोहराव की संख्या की गणना कर सकते हैं। कुछ प्रोग्रामिंग भाषाओं में एक आदेश होता है जो रूसी में repeat(number of times) जैसा लगता है, जो कोष्ठक में दोहराव की सटीक संख्या दर्शाता है। 

यह देखना दिलचस्प है कि यह चक्र मशीन स्तर पर कैसे काम करता है:
1. एक निश्चित मेमोरी सेल को मेमोरी में आवंटित किया जाता है और पुनरावृत्ति की संख्या को लिखा जाता है;
2. जब प्रोग्राम लूप बॉडी को एक बार निष्पादित करता है, तो इस सेल (काउंटर) की सामग्री एक से कम हो जाती है;
3. इस सेल के शून्य होने पर लूप निष्पादन समाप्त हो जाता है।

C++ प्रोग्रामिंग लैंग्वेज में ऐसा कोई कंस्ट्रक्शन नहीं है, लेकिन for कंस्ट्रक्शन है।  

for लूप स्टेटमेंट का सामान्य रूप इस प्रकार है: के लिए (/*अभिव्यक्ति1*/; /*अभिव्यक्ति2*/; /*अभिव्यक्ति3*/ ) { /*एक स्टेटमेंट या स्टेटमेंट का ब्लॉक - लूप बॉडी*/; } इस डिज़ाइन के लिए आवश्यक है कि हम:
1. स्पष्ट रूप से एक मेमोरी सेल आवंटित करें जो एक काउंटर होगा और इसका प्रारंभिक मूल्य निर्धारित करेगा;
2. एक कंडीशन लिखी गई थी जिसके तहत लूप बॉडी को एक्जीक्यूट किया जाएगा;
3. निर्दिष्ट करें कि इस सेल में मान कैसे बदलेगा।

व्यावहारिक भाग में, हम "Hello"  शब्द को 10 बार प्रदर्शित करने का प्रयास करेंगे। निम्नलिखित कार्यों में, हम इस निर्माण का अधिक विस्तार से विश्लेषण करेंगे।

Training problem

प्रोग्रामिंग में लूप्स

for
लूप
फॉर लूप बार-बार की जाने वाली क्रियाओं के माध्यम से आगे बढ़ने का माध्यम है। आइए करीब से देखें कि यह कैसे काम करता है।

रनिंग <कोड>फॉर लूप में निम्नलिखित चरण होते हैं: 
1. लूप वेरिएबल (काउंटर) का प्रारंभिक मान सेट करना;
2. लूप को जारी रखने के लिए शर्तों की जांच;
3. एक कदम (लूप बॉडी) का निष्पादन; 
4. लूप वेरिएबल का मान बदलना।
आगे, चरण 2-4 तब तक दोहराए जाते हैं जब तक कि दूसरे चरण की स्थिति & nbsp; असत्य न हो जाए। जैसे ही कंडीशन झूठी हो जाती है, लूप समाप्त हो जाता है और लूप स्टेटमेंट for के बाद का स्टेटमेंट।
निष्पादित हो जाता है।

आइए हम लूप स्टेटमेंट के सामान्य रूप पर लौटते हैं और सभी भागों का अधिक विस्तार से विश्लेषण करते हैं।
के लिए (/*अभिव्यक्ति1*/; /*अभिव्यक्ति2*/; /*अभिव्यक्ति3*/ ) {       /*एक स्टेटमेंट या स्टेटमेंट का ब्लॉक - लूप बॉडी*/; }

अभिव्यक्ति 1 लूप वेरिएबल (काउंटर) के प्रारंभिक मान को सेट करने के लिए जिम्मेदार, अर्धविराम के साथ समाप्त होता है

उदाहरण के लिए,

1)i=0;    // लूप वेरिएबल i.
के लिए शून्य के बराबर प्रारंभिक मान निर्दिष्ट करें                  // इस अंकन के साथ, चर i को लूप से पहले घोषित किया जाना चाहिए।

2) int i=0; //  वेरिएबल i को सीधे लूप हेडर में घोषित किया जा सकता है, लेकिन
                     // इस मामले में, लूप को स्मृति से मिटाने के बाद

3) <कोड>;    // चक्र चर का कोई आरंभीकरण और घोषणा बिल्कुल नहीं,
          //  इस स्थिति में इसे लूप से पहले परिभाषित किया जा सकता है।


अभिव्यक्ति 2 लूप निरंतरता की स्थिति है के लिए जिसका सत्य होने के लिए परीक्षण किया जाता है।

i<=10  // लूप तब तक चलेगा जब तक वेरिएबल i 10 से कम या उसके बराबर है। स्थिति कुछ भी हो सकती है।
 

Expression 3 काउंटर वेरिएबल के मान को बदल देता है। इस मान के बिना, लूप को अनंत माना जाएगा।

i++  // वेरिएबल i प्रत्येक चरण के साथ 1 की वृद्धि होगी।
 

Training problem

लूप के लिए सुविधाएँ

अगर लूप बॉडी में एक स्टेटमेंट है

यदि लूप बॉडी में केवल एक कथन है, तो कोष्ठकों को छोड़ा जा सकता है।

Training problem

हेडिंग फॉर लूप - अभ्यास

साइकिल <कोड>के लिए -विशेषताएं

प्रत्येक शीर्षलेख भाग में अल्पविराम द्वारा अलग-अलग कथन हो सकते हैं।
 
उदाहरण
के लिए (i = 0, x = 1.; i < 10; i += 2, x *= 0.1) {... } इस मामले में, हम दो वेरिएबल्स का उपयोग करते हैं जो लूप बॉडी के निष्पादन के बाद बदल जाएंगे - ये वेरिएबल्स i और x हैं। चर i चरण 2 में बदलता है: i += 2 i = i + 2 के लिए आशुलिपि है। प्रत्येक चरण x = x * 0.1, x *= 0.1 के साथ चर x 0.1 गुना बढ़ जाता है।

Training problem

लूप हेडर के लिए - विशेषताएं

एन बार दोहराएं

for लूप वाले सभी प्रोग्राम जिन्हें हमने अब तक लिखा है, उन्हें यूनिवर्सल नहीं कहा जा सकता है। क्योंकि हम खुद को लूप बॉडी के दोहराव की संख्या निर्धारित करते हैं। लेकिन क्या होगा अगर दोहराव की संख्या किसी अन्य मूल्य पर निर्भर करती है? उदाहरण के लिए, उपयोगकर्ता स्वयं चक्र के दोहराव की संख्या निर्धारित करना चाहता है।
इस मामले में क्या करें? सब कुछ बहुत आसान है। संख्यात्मक प्रारंभ और समाप्ति मानों के बजाय, हम ऐसे किसी भी चर का उपयोग कर सकते हैं जिसकी गणना या उपयोगकर्ता द्वारा सेट की जा सकती है।

उदाहरण के लिए, हमें 1 से N तक की संख्याओं के वर्ग प्रदर्शित करने की आवश्यकता है, जहां वेरिएबल N का मान कीबोर्ड से दर्ज किया जाता है उपयोगकर्ता।
कार्यक्रम कुछ इस तरह दिखेगा:
  #शामिल <iostream> नेमस्पेस एसटीडी का उपयोग करना; मुख्य() { इंट आई, एन; // बुंदाबांदी में; पाश चर, एन - अधिकतम संख्या जिसके लिए हम वर्ग की गणना करते हैं सिने>> एन; for (i = 1; i <= N; i++) // लूप: for all i from 1 to N. Variable i क्रमिक रूप से 1 से N तक मान लेगा { cout << "वर्ग संख्या "<<i<<" है" <<मैं*मैं<<"\n"; // किसी संख्या के वर्ग को एक विशिष्ट प्रारूप में आउटपुट करना और एक नई पंक्ति में जाना } } लूप में प्रवेश करते समय, कथन i = 1 निष्पादित किया जाता है, और फिर चर i को प्रत्येक चरण के साथ एक से बढ़ाया जाता है (i ++ ). स्थिति i <= N के सत्य होने पर लूप निष्पादित किया जाता है। लूप की बॉडी में, केवल आउटपुट स्टेटमेंट ही संख्या और उसके वर्ग को निर्दिष्ट प्रारूप के अनुसार स्क्रीन पर प्रिंट करता है।
वर्ग करने या अन्य निम्न घातांकों के लिए, गुणन का उपयोग करना बेहतर होता है।

प्रोग्राम को रन करें और वेरिएबल N के विभिन्न मानों के साथ इसके कार्य का परिणाम देखें।

Training problem

फॉर लूप का हेडर - एन-बार दोहराना