C Language
Iteration कथन / लूप्स: के लिए, जबकि, करते समय

वाक्य - विन्यास

• /* सभी संस्करण */
• ([अभिव्यक्ति]; [अभिव्यक्ति]; [अभिव्यक्ति]) one_statement
• ([अभिव्यक्ति]; [अभिव्यक्ति]; [अभिव्यक्ति]) {शून्य या कई कथन}
• जबकि (अभिव्यक्ति) one_statement
• जबकि (अभिव्यक्ति) {शून्य या कई कथन}
• one_statement करते समय (अभिव्यक्ति);
• do {एक या अधिक कथन} जबकि (अभिव्यक्ति);
• // ऊपर के फॉर्म के अलावा C99 से
• for (घोषणा; [अभिव्यक्ति]; [अभिव्यक्ति]) one_statement;
• के लिए (घोषणा; [अभिव्यक्ति]; [अभिव्यक्ति]) {शून्य या कई कथन}

टिप्पणियों

for ([<expression>]; [<expression>]; [<expression>]) <statement>
while (<expression>) <statement>

for ([declaration expression]; [expression] [; [expression]]) statement

do <statement> while (<expression>);

पाश के लिए

बार-बार कोड के ब्लॉक को निष्पादित करने के लिए, लूप्स चित्र में आते हैं। for पाश कोड का एक खंड समय की एक निश्चित संख्या को मार डाला है जब इस्तेमाल किया जा रहा है। उदाहरण के लिए, उपयोगकर्ता इनपुट के साथ आकार n की एक सरणी को भरने के लिए, हमें n लिए scanf() को निष्पादित करना होगा।

#include <stddef.h>          // for size_t

int array[10];               // array of 10 int

for (size_t i = 0; i < 10; i++)    // i starts at 0 and finishes with 9
{
   scanf("%d", &array[i]);
}

इस तरह से scanf() फ़ंक्शन कॉल को n बार निष्पादित किया जाता है (हमारे उदाहरण में 10 बार), लेकिन केवल एक बार लिखा जाता है।

यहाँ, वैरिएबल i लूप इंडेक्स है, और इसे सबसे अच्छे रूप में प्रस्तुत किया गया है। डेटा ऑब्जेक्ट्स के माध्यम से उन सभी चीज़ों के लिए size_t ( आकार प्रकार ) का उपयोग किया जाना चाहिए जो मायने रखता है या लूप करता है।

अंदर चर घोषित करने के इस तरह for compilers कि C99 मानक के लिए अद्यतन किया गया है के लिए ही उपलब्ध है। यदि किसी कारण से आप अभी भी पुराने कंपाइलर के साथ अटके हैं तो आप लूप इंडेक्स को लूप के for घोषित कर सकते हैं:

#include <stddef.h>        /* for size_t */
size_t i;
int array[10];             /* array of 10 int */

for (i = 0; i < 10; i++)       /* i starts at 0 and finishes at 9 */
{
   scanf("%d", &array[i]);
}

घुमाव के दौरान

एक while पाश कोड का एक टुकड़ा निष्पादित करने के लिए, जबकि एक की हालत सच है प्रयोग किया जाता है। while लूप का उपयोग तब किया जाता है जब कोड के एक ब्लॉक को एक चर संख्या को निष्पादित करना होता है। उदाहरण के लिए दिखाए गए कोड को उपयोगकर्ता इनपुट प्राप्त होता है, जब तक कि उपयोगकर्ता उन संख्याओं को सम्मिलित करता है जो 0 नहीं हैं। यदि उपयोगकर्ता 0 सम्मिलित करता है, जबकि स्थिति अभी सच नहीं है, तो निष्पादन लूप से बाहर निकल जाएगा और किसी भी बाद के कोड पर जारी रहेगा:

int num = 1;

while (num != 0)
{
    scanf("%d", &num);
}

दोहा- पाश

विपरीत for और while छोरों, do-while छोरों पाश, जिसका अर्थ है के अंत में स्थिति की सच्चाई की जांच do ब्लॉक एक बार निष्पादित करेंगे, और फिर की स्थिति की जांच while ब्लॉक के तल पर। मतलब यह कि एक लूप do-while लूप हमेशा कम से कम एक बार चलेगा।

उदाहरण के लिए, इस do-while लूप को उपयोगकर्ता से नंबर मिलेंगे, जब तक कि इन मानों का योग 50 से अधिक या उसके बराबर न हो:

int num, sum;
num = sum = 0;

do 
{
  scanf("%d", &num);
  sum += num;

} while (sum < 50);

अधिकांश प्रोग्रामिंग शैलियों में लूप do-while लूप अपेक्षाकृत दुर्लभ हैं।

लूप के लिए संरचना और नियंत्रण का प्रवाह

for ([declaration-or-expression]; [expression2]; [expression3])
{
    /* body of the loop */
}

एक में for पाश, पाश हालत तीन भाव, सभी वैकल्पिक है।

• पहला एक्सप्रेशन, declaration-or-expression , लूप को इनिशियलाइज़ करता है। यह लूप की शुरुआत में एक बार बिल्कुल निष्पादित होता है।

• दूसरी अभिव्यक्ति, expression2 , परीक्षण की स्थिति है । इसे पहले इनिशियलाइजेशन के बाद निष्पादित किया जाता है। यदि स्थिति true , तो नियंत्रण लूप के शरीर में प्रवेश करता है। यदि नहीं, तो यह लूप के अंत में लूप के शरीर के बाहर शिफ्ट होता है। इसके बाद, शरीर के प्रत्येक निष्पादन के साथ-साथ अपडेट स्टेटमेंट के बाद इस कॉन्डिटॉन की जाँच की जाती है। जब true , तो नियंत्रण लूप के शरीर की शुरुआत में वापस चला जाता है। हालत आमतौर पर लूप निष्पादित करने वाले शरीर की संख्या पर एक चेक होने का इरादा है। यह एक लूप से बाहर निकलने का प्राथमिक तरीका है, दूसरा तरीका जम्प स्टेटमेंट का उपयोग किया जा रहा है।
• तीसरी अभिव्यक्ति, expression3 , अपडेट स्टेटमेंट है । यह लूप के शरीर के प्रत्येक निष्पादन के बाद निष्पादित किया जाता है। यह अक्सर लूप बॉडी को निष्पादित करने की संख्या की गणना के लिए एक वैरिएबल को बढ़ाने के लिए उपयोग किया जाता है, और इस चर को एक इटरेटर कहा जाता है ।

लूप शरीर के निष्पादन के प्रत्येक उदाहरण को एक पुनरावृत्ति कहा जाता है।

उदाहरण:

for(int i = 0; i < 10 ; i++)
{
    printf("%d", i);
}

आउटपुट है:

0123456789

उपरोक्त उदाहरण में, पहले i = 0 को निष्पादित किया जाता है, i प्रारंभ करता है। फिर, i < 10 की जाँच की जाती है, जो कि true होने का मूल्यांकन करता true । नियंत्रण लूप के शरीर में प्रवेश करती है और का मान i छपा है। फिर, नियंत्रण i++ स्थानांतरित हो जाता है, i 0 से 1 तक के मूल्य को अद्यतन करता है। फिर, स्थिति को फिर से जांचा जाता है, और प्रक्रिया जारी रहती है। यह तब तक चलता है जब तक i का मान 10 नहीं हो जाता है। तब, i < 10 मूल्यांकन false , जिसके बाद नियंत्रण लूप से बाहर हो जाता है।

अनंत लूप्स

एक लूप को एक अनंत लूप कहा जाता है यदि नियंत्रण प्रवेश करता है लेकिन लूप के शरीर को कभी नहीं छोड़ता है। यह तब होता है जब लूप की परीक्षण स्थिति कभी भी false मूल्यांकन नहीं करती है।

उदाहरण:

for (int i = 0; i >= 0; )
{
    /* body of the loop where i is not changed*/
}

उपरोक्त उदाहरण में, वैरिएबल i , इट्रेटर, को इनिशियलाइज़ किया गया है। टेस्ट की स्थिति शुरू में true । हालाँकि, i शरीर में कहीं भी संशोधित नहीं किया गया है और अद्यतन अभिव्यक्ति खाली है। इसलिए, i 0 बना रहूंगा, और परीक्षण की स्थिति कभी भी false मूल्यांकन नहीं करेगी, जिससे अनंत लूप बन जाएगा।

यह मानते हुए कि कोई जम्प स्टेटमेंट्स नहीं हैं , एक और तरीका है कि एक अनंत लूप का गठन किया जा सकता है, यह स्पष्ट रूप से स्थिति को सही रखता है:

while (true)
{
    /* body of the loop */
}

एक में for पाश, हालत बयान वैकल्पिक। इस स्थिति में, स्थिति हमेशा रिक्त रूप से true होती है, जिससे अनंत लूप बन जाता है।

for (;;)
{
    /* body of the loop */
}

हालांकि, कुछ मामलों में, स्थिति को जानबूझकर true रखा जा सकता है, एक break स्टेटमेंट जैसे break का उपयोग करके लूप से बाहर निकलने के इरादे से।

while (true)
{
    /* statements */
    if (condition)
    {
         /* more statements */
         break;
    }
}

लूप अनरोलिंग और डफ डिवाइस

कभी-कभी, सीधे फॉरवर्ड लूप को पूरी तरह से लूप बॉडी के भीतर समाहित नहीं किया जा सकता है। ऐसा इसलिए है, क्योंकि लूप को कुछ कथनों B द्वारा प्राइम करने की आवश्यकता है। फिर, पुनरावृत्ति कुछ बयान ए के साथ शुरू होती है, जो बाद में लूपिंग से पहले बी फिर से होती है।

do_B();
while (condition) {
    do_A();
    do_B();
}

कोड में बी को दो बार दोहराने के साथ संभावित कट / पेस्ट की समस्याओं से बचने के लिए, स्विच स्टेटमेंट का उपयोग while और व्यवहार के माध्यम से गिरने के while , डफ डिवाइस को शरीर के बीच से लूप शुरू करने के लिए लागू किया जा सकता है।

switch (true) while (condition) {
case false: do_A(); /* FALL THROUGH */
default:    do_B(); /* FALL THROUGH */
}

डफ डिवाइस वास्तव में लूप को अनियंत्रित करने के लिए आविष्कार किया गया था। एक मुखौटा को स्मृति के एक ब्लॉक पर लागू करने की कल्पना करें, जहां n एक सकारात्मक मूल्य के साथ एक हस्ताक्षरित अभिन्न प्रकार है।

do {
    *ptr++ ^= mask;
} while (--n > 0);

यदि n हमेशा 4 से विभाज्य थे, तो आप इसे आसानी से नियंत्रित कर सकते हैं:

do {
    *ptr++ ^= mask;
    *ptr++ ^= mask;
    *ptr++ ^= mask;
    *ptr++ ^= mask;
} while ((n -= 4) > 0);

लेकिन, डफ डिवाइस के साथ, कोड इस अनियंत्रित मुहावरे का पालन कर सकता है जो लूप के बीच में सही जगह पर कूदता है यदि n 4 से विभाज्य नहीं है।

switch (n % 4) do {
case 0: *ptr++ ^= mask; /* FALL THROUGH */
case 3: *ptr++ ^= mask; /* FALL THROUGH */
case 2: *ptr++ ^= mask; /* FALL THROUGH */
case 1: *ptr++ ^= mask; /* FALL THROUGH */
} while ((n -= 4) > 0);

आधुनिक संकलक के साथ इस तरह की मैनुअल अनरोलिंग की शायद ही कभी आवश्यकता होती है, क्योंकि कंपाइलर का ऑप्टिमाइज़ेशन इंजन प्रोग्रामर की ओर से लूप को अनियंत्रित कर सकता है।