Tip:
Highlight text to annotate it
X
[Powered by Google Translate] : टॉमी MACWILLIAM loops के बारे में बात करते हैं, एक आम के
प्रोग्रामिंग constructs हम CS50 भर में देखेंगे.
हम loops का उपयोग जब हम एक प्रदर्शन करना चाहता हूँ
कार्य एक बार से अधिक है.
उदाहरण के लिए, हम "हाय" 100 बार या प्रिंट करना चाहते हो सकता है
वर्णमाला के सभी अक्षरों के बाहर.
इन दोनों मामलों में, हम एक बात हम करना चाहते है
कई बार, कुछ प्रिंट.
हालांकि, हम क्या बाहर प्रिंट हर बार बदल सकते हैं.
इसलिए हम प्रत्येक पर थोड़ा अलग कुछ कर सकते हैं
चलना, या के माध्यम से चलाने के लिए, लूप के.
हम सी में loops के तीन अलग अलग प्रकार देखते हैं, जबकि हूँ
loops के लिए, loops और loops जबकि.
हालांकि loops के इन तीन प्रकार एक अलग वाक्यविन्यास है,
उनके विचारों के पीछे वही कर रहे हैं.
हम घुंघराले ब्रेसिज़ के भीतर कोड के कुछ खंड परिभाषित करेंगे,
लूप के शरीर कहा जाता है, कि हम क्रियान्वित किया जा चाहते
समय की कुछ संख्या.
शरीर में इस्तेमाल किया चर के मूल्यों से बदल रहा है, हम
हमारे पाश अलग हर बार इसे चलाने के लिए है कुछ कर सकते हैं.
किसी भी पाश हम लिखने के साथ, हम यह भी तय करना होगा जब
पाश चलना बंद कर देंगे.
यदि हम ऐसा नहीं करते हैं, तो हमारे भरोसेमंद कंप्यूटर जारी रहेगा
कि पाश चलाने के लिए जब तक हम कार्यक्रम को मारने के लिए.
स्क्रैच में, हम दोहराने n बार इस्तेमाल कर सकते हैं
एक पाश बनाने के ब्लॉक.
एक ब्लॉक के अंदर टुकड़े के सभी कि 10 दोहराने कहा
10 बार चलाया जाएगा.
और फिर, हम पर है कि पाश के बाद टुकड़े करने के लिए कदम था.
तो हमारे रोक की हालत में बस गया था, इस ब्लॉक कर दिया गया है
10 बार चलाते हैं.
तो चलो आदेश में सी. में यह सुनिश्चित करने के लिए के लिए स्क्रैच बहलाना
कि दोहराने ब्लॉक के भीतर टुकड़े क्रियान्वित कर रहे हैं
वास्तव में 10 बार, स्क्रैच करने के लिए प्रत्येक का ट्रैक रखने की जरूरत है
दोहराने ब्लॉक के निष्पादन.
कितनी बार हमारे पाश शरीर दिया गया है का ट्रैक रखने
निष्पादित, चलो मैं एक चर बुलाया.
हम मैं शुरू से शून्य पर हमारे पाश के बाद से,
चला गया है अभी तक नहीं है.
अच्छा
अब हम जबकि खोजशब्द का उपयोग करने के लिए हमारे पाश शुरू करेंगे.
अब हम यह पता लगाने के लिए जब हमारे पाश बंद हो जाएगा जरूरत है, लेकिन
चलो अब के लिए छोड़ दो और फिर इसे वापस आ जाओ.
सही सभी.
हमारे लूप के अंदर, चलो बस एक संदेश बाहर प्रिंट, की तरह
"नमस्ते." हम इस बात के लिए printf समारोह का उपयोग कर सकते हैं.
सही सभी.
तो अब हम दर्ज करेंगे कि पाश शरीर के एक चलना है
निष्पादित किया गया.
हम 1 जोड़ने, या incrementing द्वारा करते हैं कि, हमारे काउंटर
चर, मैं.
करना है कि, हम कह सकते हैं कि मैं मैं प्लस 1 या अधिक करने के लिए बराबर है
बस, मैं प्लस प्लस.
बढ़िया है.
तो अब हम है कि हर बार हमारे पाश चलाया जाता है देख सकते हैं, हमारे
काउंटर चर एक से ऊपर चला जाता है.
तो हम जानते हैं कि वास्तव में कितने पुनरावृत्तियों हम इतनी दूर भाग लिया.
पाश की एक के बाद चलना, हमारे मूल्य
मैं 1 हो जाएगा.
दो iterations के बाद, मैं 2 का हो जाएगा.
और 10 पुनरावृत्तियों के बाद, मैं 10 का हो जाएगा.
तो, अगर हम इस लूप को चलाने चाहते हैं वास्तव में 10 बार फिर,
यह है कि जब हम बंद करना चाहते हैं.
तो हम इस लूप को चलाने जबकि मैं कम से कम 10 है चाहते हैं, और
कि वास्तव में हम क्या लिख देंगे है, जबकि मैं
कम से कम 10 है.
इस हालत में अगर शर्तों हम इस्तेमाल की तरह लग रहा है
किसी और को रोकता है.
हमारे पाश के शरीर के बाद मार डाला गया है, हमारे कार्यक्रम
वापस ऊपर loops हालत के लिए कूद जाएगा.
अगर हालत सच है, तो के शरीर
पाश फिर से चलाया जाएगा.
अगर हालत सच नहीं है, तो हमारे पाश नहीं होगा
अब चलाने के लिए और कोड की अगली पंक्ति के लिए आगे बढ़ना होगा
हमारे पाश नीचे.
सही सभी.
तो चलो एक दूसरे प्रकार की पर एक नज़र रखना
पाश, पाश के लिए.
जबकि खोजशब्द के आगे कोष्ठक में, हम एक बात थी,
शर्त यह है कि करने के लिए सच हो सकता है की जरूरत है
पाश शरीर चलाने के लिए.
मतलब है कि हम हमारे काउंटर चर बाहर बनाने के लिए किया था
और कुछ बिंदु पर पाश याद करने के लिए यह वेतन वृद्धि
अंदर पाश.
पाश के लिए हमारे लिए हैडर, दूसरे हाथ पर, तीन
भागों, जिनमें से प्रत्येक एक सेमीकोलन के साथ अलग हो जाएगा.
हमारी पहली 3 में, हम किसी भी काउंटर या सहायक की घोषणा कर सकते हैं
चर हम हमारे पाश में उपयोग करना चाहते हैं.
व्यवहार में, यह वास्तव में मददगार हो सकता है.
हम वास्तव में हमारे समय के बाद कि चर, मैं की जरूरत नहीं है
पाश चला गया है, तो हम वास्तव में यह घोषणा नहीं होना चाहिए
लूप के बाहर.
2 3 शर्त है कि सच होना चाहिए होगा
के लिए शरीर को फिर से निष्पादित करने के लिए जैसे,
हमारे जबकि पाश में.
हमारे पिछले 3 में, हम एक बयान दिया था कि हो जाएगा चला सकते हैं
लूप के प्रत्येक चलना के बाद मार डाला, तो हमारे पास नहीं है
यह पाश शरीर में निर्माण.
तो चलो पाश है कि 5 से 1 के लिए नीचे की गिनती के लिए एक लिखने.
हम के लिए कीवर्ड के साथ शुरू करेंगे.
पहले हम एक काउंटर चर बना सकते हैं, जो हम करेंगे
5 करने के लिए इस समय सेट के बाद से हम नीचे की गिनती कर रहे हैं,
एक अर्धविराम से पीछा किया.
अगले हमारे हालत है, जो हम वापस करने के लिए आया हूँ.
तीसरा, हम करने के बाद हमारे काउंटर चर घटती करना चाहते हैं
लूप के प्रत्येक चलना.
तो मैं प्लस प्लस कह के बजाय, हम मैं शून्य शून्य से कहूँगा.
सही सभी.
तो हम पाश शरीर जबकि मैं अभी भी चलाने के लिए करना चाहते हैं
0 से अधिक है.
पाश के शरीर में, चलो बाहर मैं के मूल्य मुद्रित.
ऐसा करने के लिए, हम printf समारोह का उपयोग करने के लिए,% d का उपयोग करेंगे
प्लेसहोल्डर.
याद रखें, कि प्लेसहोल्डर साथ प्रतिस्थापित किया जाएगा
मैं के मूल्य.
अंत में, चलो पाश के लिए हमारे बाद एक बयान जोड़ने है.
जब हम इस पाश चलाते हैं, मैं 5 में शुरू कर देंगे,
तो 5 मुद्रित किया जाएगा.
एक बार जब मैं 0 करने के लिए हो जाता है, निरंतरता हालत, मैं
0 से अधिक नहीं रह आयोजन करेगा.
तो हमारे पाश निष्पादित बंद करो, और हम देखेंगे
लूप के बाद बयान.
तो चलो इस कोड को चलाने.
सबसे पहले, हम एक संकलन हूँ
उलटी गिनती बनाने के साथ countdown.c.
अब, हम उलटी गिनती / के साथ इस कोड को चला सकते हैं.
जबकि दोनों loops और loops के लिए, हमारे निरंतरता
हालत शरीर पहले जाँच की जाएगी
के पाश मार डाला है.
इसका मतलब है कि अगर हमारी हालत शुरू नहीं है
सच है, तो हमारे पाश के शरीर चलाए जा कभी नहीं होगा.
तो यह कभी कभी के बाद हालत की जांच करने के लिए उपयोगी
पाश की बल्कि शरीर की तुलना में यह पहले.
तो चलो एक पाश लिखने के लिए एक नंबर के लिए उपयोगकर्ता prompt
जब तक एक सकारात्मक संख्या की आपूर्ति की है.
यदि उपयोगकर्ता एक नकारात्मक संख्या आदानों, हम उन्हें पूछना चाहता हूँ
दूसरे नंबर के लिए.
इसलिए हम इस शीघ्र करने के लिए अंदर होना चाहता हूँ
पाश बंद शरीर.
हालांकि, जब पाश में पहली बार के लिए चलाया जाता है, उपयोगकर्ता
संख्या को देखते हुए हमें अभी तक नहीं है.
तो यह समझ में नहीं करने के लिए जाँच अगर यह सकारात्मक है.
इसके बजाय, हम शरीर के बाद नंबर की जांच करने के लिए चाहता हूँ
पाश चलाया जाता है.
हम पाश जबकि एक नहीं है के साथ कर सकते हैं.
सबसे पहले, हम एक चर बनाने के लिए, पता है, कि आयोजन करेगा
उपयोगकर्ता इनपुट.
अब हम कीवर्ड, घुंघराले ब्रेसिज़ द्वारा पीछा इस्तेमाल करेंगे कि
हमारे पाश के शरीर से शुरू कर देंगे.
शरीर में, हम साथ एक नंबर के लिए उपयोगकर्ता का संकेत कर सकते हैं
समारोह GetInt.
अब, हम इस लूप के शरीर को फिर से निष्पादित करने के लिए चाहता हूँ अगर
उपयोगकर्ता एक नकारात्मक संख्या टाइप है, तो हम कहेंगे जबकि n
कम से कम 0 है.
सेमीकोलन यहाँ ध्यान दें जबकि बयान के बाद.
तो चलो इस कोड को चलाने.
सबसे पहले, हम सकारात्मक बनाने के साथ यह संकलन हूँ.
अब हम साथ कार्यक्रम चलाने के सकारात्मक / कर सकते हैं.
यदि हम इस कार्यक्रम नकारात्मक की तरह एक नकारात्मक संख्या, दे
4, तो हम के बाद से एक नंबर के लिए फिर से पूछा जाएगा
हमारे do की हालत जबकि पाश सच था.
एक बार जब हम एक सकारात्मक नंबर दे, तो 8 की तरह,
हमारे do की हालत जबकि पाश अब सच हो जाएगा.
तो पाश फिर से क्रियान्वित नहीं किया जाएगा.
और कहा कि यह loops के तीन प्रकार हम सी. में उपयोग करेंगे के लिए है
मेरा नाम टॉमी है, और इस CS50 है.