C లూప్స్ (while, do-while, for) & ఇటరేషన్ సైకిల్

కంట్రోల్ ఫ్లో ప్రోగ్రామింగ్‌లో లూప్స్ అనేవి గుండెకాయ వంటివి. డేటాను ప్రాసెస్ చేయాలన్నా, ఫైళ్లను చదవాలన్నా, గ్రాఫిక్స్ రెండర్ చేయాలన్నా లూప్స్ లేకుండా ఏ కంప్యూటర్ సాఫ్ట్‌వేర్ పనిచేయదు. ఈ పాఠంలో కవర్ చేయబడే సమగ్ర అంశాలు:

• లూపింగ్ ప్రాథమిక ఆవశ్యకత: కోడ్ డూప్లికేషన్ (DRY - Don't Repeat Yourself) నివారణ మరియు మెమరీ పొదుపు.
• లూప్ 4-దశల లైఫ్‌సైకిల్: Initialization, Condition Evaluation, Body Execution, మరియు Update/Step Expression.
• while లూప్ (Entry-Controlled): కండిషన్ ట్రూ అయితేనే లోపలికి అనుమతించే సెక్యూరిటీ గార్డ్ ఆర్కిటెక్చర్.
• do-while లూప్ (Exit-Controlled): కండిషన్ ఫాల్స్ అయినా కనీసం ఒక్కసారైనా రన్ అయ్యే గ్యారెంటీడ్ మోడల్.
• for లూప్ (Compact Iteration): 3 ఎక్స్‌ప్రెషన్లు ఒకే లైన్‌లో ఉండే క్లీన్ ఇంజనీరింగ్ డిజైన్.
• C99 వేరియబుల్ స్కోపింగ్: for (int i = 0; ...) ద్వారా లూప్ లోపల వేరియబుల్స్ ఐసొలేట్ చేయడం.
• తులనాత్మక విశ్లేషణ పట్టిక: for vs while vs do-while - ఏ సందర్భంలో దేనిని ఎంచుకోవాలి?
• ఇన్ఫినిట్ లూప్స్ (Infinite Loops): while(1), for(;;) ఎప్పుడు వాడాలి? CPU 100% స్టాల్ అవ్వకుండా ఎలా ఆపాలి?
• ఆఫ్-బై-వన్ (Off-by-One / Fencepost) బగ్స్: ప్రపంచ ప్రసిద్ధ సాఫ్ట్‌వేర్ క్రాష్‌లకు కారణమయ్యే < vs <= పొరపాట్లు.
• ప్రీ-ఇంక్రిమెంట్ (++i) vs పోస్ట్-ఇంక్రిమెంట్ (i++): లూప్ హెడర్‌లో ఏది వేగవంతమైనది?
• కంపైలర్ ఆప్టిమైజేషన్స్: లూప్ అన్‌రోలింగ్ (Loop Unrolling) మరియు బ్రాంచ్ ప్రిడిక్షన్ (Branch Prediction).
• రియల్ వరల్డ్ ప్రాజెక్ట్ 1: 3-స్టెప్ ATM పిన్ వాలిడేషన్ & ఖాతా తాత్కాలిక లాకౌట్ సిస్టమ్.
• రియల్ వరల్డ్ ప్రాజెక్ట్ 2: ఫైనాన్షియల్ కాంపౌండ్ ఇంట్రెస్ట్ ప్రొజెక్షన్ టేబుల్ జనరేటర్.
• ఇంటరాక్టివ్ స్వీయ మూల్యాంకన క్విజ్: 5 లోతైన విశ్లేషణాత్మక ప్రశ్నలు & ఎగ్జామ్ కాన్సెప్ట్స్.

C లాంగ్వేజ్‌లో మీరు ఏ లూప్ రాసినా (అది while అయినా, do-while అయినా, లేదా for అయినా) ప్రతి లూప్ కచ్చితంగా 4 కీలక దశలను (Four Core Phases) కలిగి ఉంటుంది. ఈ నాలుగు దశలలో ఏ ఒక్కటి లోపించినా, మీ ప్రోగ్రామ్ విఫలమవ్వడమో లేదా నిరంతరం తిరుగుతూ కంప్యూటర్‌ను హ్యాంగ్ చేయడమో జరుగుతుంది!

while లూప్ అనేది C లాంగ్వేజ్‌లోని అత్యంత ప్రాథమికమైన లూప్. దీనిని ఎంట్రీ-కంట్రోల్డ్ లూప్ (Entry-Controlled Loop) అంటారు. ఎందుకంటే లూప్ బాడీ లోపలికి ప్రవేశించే ముందే మెయిన్ గేటు వద్ద సెక్యూరిటీ గార్డులా కండిషన్‌ను తనిఖీ చేస్తుంది. కండిషన్ ట్రూ అయితేనే లోపలికి అనుమతిస్తుంది; మొదటి ప్రయత్నంలోనే కండిషన్ ఫాల్స్ అయితే, లూప్ బాడీ జీరో సార్లు (సున్నా సార్లు) రన్ అవుతుంది!

సింటాక్స్:

క్రింది ఉదాహరణలో 1 నుండి 5 వరకు సంఖ్యలను ప్రింట్ చేసే సింపుల్ while లూప్‌ను గమనించండి:

#include <stdio.h>

int main() {
    int i = 1; // 1. Initialization

    printf("--- while లూప్ ప్రారంభం ---\n");
    while (i <= 5) { // 2. Condition Test
        printf("కౌంటర్ విలువ: %d\n", i); // 3. Body Execution
        i++; // 4. Update / Increment
    }
    printf("--- లూప్ ముగిసింది. తుది విలువ i = %d ---\n", i);

    return 0;
}

do-while లూప్ అనేది while లూప్‌కు ఖచ్చితమైన వ్యతిరేకమైనది. దీనిని ఎగ్జిట్-కంట్రోల్డ్ లూప్ (Exit-Controlled Loop) అంటారు. ఇందులో కండిషన్ చెక్ అనేది లూప్ చివరన జరుగుతుంది. దీని అర్థం ఏమిటంటే:

కండిషన్ మొదటిసారే పూర్తిగా ఫాల్స్ (False) అయినప్పటికీ, లూప్ బాడీ కచ్చితంగా కనీసం ఒక్కసారైనా (At least once) ఎగ్జిక్యూట్ అవుతుంది!

సింటాక్స్ & సెమికోలన్ హెచ్చరిక:

క్రింది ఉదాహరణలో కండిషన్ score > 100 అనేది మొదటి నుంచే ఫాల్స్. అయినా బాడీ ఎలా రన్ అవుతుందో చూడండి:

#include <stdio.h>

int main() {
    int score = 50;

    printf("do-while లోపలికి ప్రవేశిస్తున్నాం...\n");
    do {
        printf("ఈ మెసేజ్ కనీసం ఒక్కసారైనా ప్రింట్ అవుతుంది! Current score = %d\n", score);
        score += 10;
    } while (score > 100); // 60 > 100 అనేది FALSE!

    printf("do-while ముగిసింది! Condition ఫాల్స్ అయినా బాడీ ఒక్కసారి రన్ అయింది.\n");
    return 0;
}

రియల్ వరల్డ్ ప్రాక్టికల్ అప్లికేషన్:

సాఫ్ట్‌వేర్ ఇంజనీరింగ్‌లో యూజర్ ఇన్‌పుట్ వాలిడేషన్ మరియు ఇంటరాక్టివ్ మెనూలు రూపొందించడానికి do-while సర్వోత్తమమైనది. ఎందుకంటే యూజర్‌కు ముందుగా మెనూ లేదా ప్రాంప్ట్ చూపించాలి, తర్వాతే యూజర్ ఇచ్చిన ఇన్‌పుట్ సరైనదా కాదా అని లూప్ కండిషన్‌లో చెక్ చేయాలి!

C లాంగ్వేజ్‌లో అత్యంత ఎక్కువగా వాడబడే లూప్ for లూప్. ఎందుకంటే లూప్‌కు అవసరమైన 3 ముఖ్యమైన దశలను (ఇనిషియలైజేషన్, కండిషన్, అప్‌డేట్) ఒకే బ్రాకెట్ లోపల కాంపాక్ట్‌గా అమర్చుకునే అద్భుతమైన సౌలభ్యం ഇതിൽ ఉంది!

for లూప్ అనాటమీ & ఎగ్జిక్యూషన్ ఆర్డర్:

#include <stdio.h>

int main() {
    int n = 7; // 7వ ఎక్కం (Table of 7)

    printf("=== 7వ ఎక్కం (7 Table using for loop) ===\n");
    for (int i = 1; i <= 10; i++) {
        printf("%d x %2d = %2d\n", n, i, n * i);
    }

    return 0;
}

C99 వేరియబుల్ స్కోపింగ్ (Block Scope in for Loops):

పాత C89 స్టాండర్డ్‌లో లూప్ కౌంటర్ వేరియబుల్‌ను ఫంక్షన్ మొదట్లోనే డిక్లేర్ చేయాల్సి వచ్చేది. కానీ ఆధునిక C99 / C11 / C17 స్టాండర్డ్స్ ప్రకారం, for (int i = 0; ...) లాగా నేరుగా లూప్ హెడర్‌లోనే వేరియబుల్‌ను డిక్లేర్ చేయవచ్చు. దీనివలన ఆ వేరియబుల్ కేవలం ఆ లూప్ లోపల మాత్రమే బ్రతుకుతుంది (Block Scope), లూప్ బయట వేరే వేరియబుల్స్‌తో ఘర్షణ పడదు (No Namespace Pollution)!

ఏ సందర్భంలో ఏ లూప్ వాడాలి? అనేది ప్రతి కొత్త ప్రోగ్రామర్‌ను వేధించే అతిపెద్ద సందేహం. ఈ క్రింది సమగ్ర పట్టికను పరిశీలించండి:

ఒక లూప్ యొక్క కండిషన్ ఎప్పటికీ ఫాల్స్ కాకపోతే, ఆ లూప్ అంతం లేకుండా నిరంతరం రన్ అవుతూనే ఉంటుంది. దీనినే ఇన్ఫినిట్ లూప్ (Infinite Loop) అంటారు. సాధారణంగా అనుభవం లేని బిగినర్స్ పొరపాటున ఇన్ఫినిట్ లూప్స్ సృష్టించి తమ ప్రోగ్రామ్‌లను క్రాష్ చేస్తుంటారు.

ఇన్ఫినిట్ లూప్స్ ఎలా ఏర్పడతాయి?

ఇన్ఫినిట్ లూప్స్ సాఫ్ట్‌వేర్ ఇంజనీరింగ్‌లో నిజంగా అవసరమా?

అవును! ఆపరేటింగ్ సిస్టమ్‌ల కెర్నల్స్ (OS Event Loops), మైక్రోకంట్రోలర్లు (Arduino/Embedded Systems లో while(1)), వెబ్ సర్వర్లు (రెక్వెస్ట్‌ల కోసం వేచి ఉండే లిజనర్లు), మరియు వీడియో గేమ్‌ల రెండరింగ్ లూప్స్ అన్నీ ఇన్ఫినిట్ లూప్స్ పైనే నడుస్తాయి. అయితే, వాటిలో కచ్చితంగా యూజర్ 'Quit' బటన్ నొక్కినప్పుడు బయటపడటానికి break స్టేట్‌మెంట్ అమర్చబడి ఉంటుంది!

#include <stdio.h>

int main() {
    int num, sum = 0;

    printf("=== సంఖ్యల కూడిక (ఆపడానికి -1 ఎంటర్ చేయండి) ===\n");
    while (1) { // కంట్రోల్డ్ ఇన్ఫినిట్ లూప్
        printf("ఒక సంఖ్యను ఎంటర్ చేయండి: ");
        scanf("%d", &num);

        if (num == -1) {
            printf("సెంటినెల్ విలువ (-1) గుర్తించబడింది. లూప్ నుండి బయటకు వస్తున్నాం...\n");
            break; // లూప్ నుండి తక్షణ నిష్క్రమణ!
        }

        sum += num;
        printf("ప్రస్తుత మొత్తం (Current Sum): %d\n", sum);
    }

    printf("తుది మొత్తం: %d\n", sum);
    return 0;
}

ప్రపంచవ్యాప్తంగా సీనియర్ సాఫ్ట్‌వేర్ ఇంజనీర్లు సైతం తరచుగా చేసే అత్యంత మోసపూరితమైన తప్పు ఆఫ్-బై-వన్ బగ్ (Off-by-One Error - OBOE). ఒక పనిని అనుకున్నదానికంటే సరిగ్గా ఒక్కసారి తక్కువగానో లేదా ఒక్కసారి ఎక్కువగానో రన్ చేయడమే ఈ బగ్!

చాలామంది ప్రోగ్రామర్లలో ఒక ఆసక్తికరమైన ప్రశ్న ఉంటుంది: "for లూప్ హెడర్‌లో i++ వాడాలా లేక ++i వాడాలా? రెండింటి మధ్య పనితీరులో (Performance) ఏమైనా తేడా ఉందా?"

// స్టైల్ 1: పోస్ట్-ఇంక్రిమెంట్
for (int i = 0; i < 5; i++) {
    printf("%d ", i); // అవుట్‌పుట్: 0 1 2 3 4
}

// స్టైల్ 2: ప్రీ-ఇంక్రిమెంట్
for (int i = 0; i < 5; ++i) {
    printf("%d ", i); // అవుట్‌పుట్: 0 1 2 3 4
}

ఆధునిక కంపైలర్లు (GCC, Clang) లూప్‌లను ఎలా ఆప్టిమైజ్ చేస్తాయో తెలుసుకోవడం ప్రొఫెషనల్ ఇంజనీరింగ్‌కు ఎంతో అవసరం. లూప్ ప్రతి ఇటరేషన్‌లోనూ CPU కండిషన్‌ను తనిఖీ చేసి మెమరీ జంప్ (JMP instruction) చేయాల్సి ఉంటుంది. ఇది బ్రాంచ్ ప్రిడిక్షన్ మిస్ అయితే సమయం వృధా అవుతుంది.

లూప్ అన్‌రోలింగ్ (Loop Unrolling) అంటే ఏమిటి?

ఇటరేషన్ల సంఖ్య తక్కువగా ఉన్నప్పుడు, కంపైలర్ లూప్ ఓవర్‌హెడ్‌ను తగ్గించడానికి లూప్ బాడీని వరుసగా కాపీ చేసి ఎగ్జిక్యూట్ చేస్తుంది. ఉదాహరణకు:

for (int i = 0; i < 4; i++) {
    sum += arr[i];
}

sum += arr[0];
sum += arr[1];
sum += arr[2];
sum += arr[3];

ఇలా చేయడం ద్వారా కండిషన్ చెకింగ్ మరియు జంప్ ఇన్‌స్ట్రక్షన్లు పూర్తిగా తొలగిపోయి, కోడ్ అత్యధిక వేగంతో (Peak CPU throughput) ఎగ్జిక్యూట్ అవుతుంది!

ఒక నిజమైన ATM మెషీన్‌లో కస్టమర్ పిన్ నంబర్ నమోదు చేసే సిస్టమ్‌ను రూపొందిద్దాం. వినియోగదారుడికి గరిష్టంగా 3 అవకాశాలు మాత్రమే ఉంటాయి. 3 సార్లు తప్పుడు పిన్ ఎంటర్ చేస్తే ఖాతా తాత్కాలికంగా బ్లాక్ అవుతుంది. సరైన పిన్ ఇవ్వగానే తదుపరి బ్యాంకింగ్ సేవలకు అనుమతిస్తుంది. దీనికి do-while లూప్ అత్యంత సరైన ఎంపిక:

#include <stdio.h>

int main() {
    const int CORRECT_PIN = 4826; // సరైన రహస్య పిన్
    int enteredPin;
    int attempts = 0;
    const int MAX_ATTEMPTS = 3;
    int authenticated = 0;

    printf("=======================================\n");
    printf("   మనా బ్యాంక్ ATM సర్వీసెస్ (Mana ATM)\n");
    printf("=======================================\n");

    do {
        attempts++;
        printf("\n[ప్రయత్నం %d/%d] దయచేసి మీ 4-అంకెల ATM పిన్ ఎంటర్ చేయండి: ", attempts, MAX_ATTEMPTS);
        scanf("%d", &enteredPin);

        if (enteredPin == CORRECT_PIN) {
            authenticated = 1;
            break; // సరైన పిన్ దొరికితే వెంటనే లూప్ నుండి నిష్క్రమించు
        } else {
            int remaining = MAX_ATTEMPTS - attempts;
            if (remaining > 0) {
                printf("❌ తప్పుడు పిన్! మీకు ఇంకా %d అవకాశాలు మాత్రమే ఉన్నాయి.\n", remaining);
            }
        }
    } while (attempts < MAX_ATTEMPTS);

    printf("\n---------------------------------------\n");
    if (authenticated) {
        printf("✅ పిన్ విజయవంతంగా ధృవీకరించబడింది!\n");
        printf("🏦 వెల్‌కమ్! మీ ఖాతాలో బ్యాలెన్స్: రూ. 75,450.00\n");
    } else {
        printf("🚨 హెచ్చరిక: మీరు 3 సార్లు తప్పుడు పిన్ నమోదు చేశారు!\n");
        printf("🔒 సెక్యూరిటీ కారణాల వల్ల మీ ATM కార్డ్ 24 గంటలు బ్లాక్ చేయబడింది.\n");
    }
    printf("=======================================\n");

    return 0;
}

ఫైనాన్షియల్ ఇంజనీరింగ్‌లో కాంపౌండ్ ఇంట్రెస్ట్ (చక్రవడ్డీ) వార్షిక వృద్ధిని అంచనా వేసే ప్రొజెక్షన్ టేబుల్ జనరేటర్‌ను for లూప్ ఉపయోగించి నిర్మిద్దాం. ప్రతి సంవత్సరం వడ్డీ అసలుకు కలుస్తూ మూలధనం ఎలా పెరుగుతుందో లూప్ ద్వారా ఖచ్చితంగా లెక్కించవచ్చు:

#include <stdio.h>

int main() {
    double principal = 100000.0; // ప్రారంభ పెట్టుబడి: రూ. 1,00,000
    double annualRate = 12.0;    // వార్షిక వడ్డీ రేటు: 12%
    int totalYears = 5;          // పెట్టుబడి కాలం: 5 సంవత్సరాలు

    printf("====================================================\n");
    printf("   కాంపౌండ్ ఇంట్రెస్ట్ ప్రొజెక్షన్ చార్ట్ (12%% వార్షిక వృద్ధి)\n");
    printf("====================================================\n");
    printf("%-8s | %-16s | %-14s | %-16s\n", "సంవత్సరం", "ప్రారంభ బ్యాలెన్స్", "వచ్చిన వడ్డీ", "ముగింపు బ్యాలెన్స్");
    printf("----------------------------------------------------\n");

    double currentBalance = principal;
    for (int year = 1; year <= totalYears; year++) {
        double interestEarned = currentBalance * (annualRate / 100.0);
        double closingBalance = currentBalance + interestEarned;

        printf("Year %-3d | రూ. %12.2f | రూ. %10.2f | రూ. %12.2f\n",
               year, currentBalance, interestEarned, closingBalance);

        currentBalance = closingBalance; // తర్వాతి సంవత్సరానికి ముగింపు బ్యాలెన్స్ ప్రారంభ బ్యాలెన్స్ అవుతుంది
    }

    printf("====================================================\n");
    printf("5 సంవత్సరాల తర్వాత మొత్తం లాభం: రూ. %.2f\n", currentBalance - principal);
    return 0;
}

ఈ పాఠంలో నేర్చుకున్న లూపింగ్ కాన్సెప్ట్‌లను క్రింది 5 లోతైన ప్రాక్టికల్ ప్రశ్నల ద్వారా పరీక్షించుకోండి: