switch-case స్టేట్‌మెంట్ & మెనూ డ్రివెన్ ప్రోగ్రామింగ్

• switch స్టేట్‌మెంట్ ప్రాథమిక భావన: మల్టీ-వే సెలెక్షన్ మరియు కస్టమర్ కేర్ IVRS మెనూ ఎనాలజీ.
• switch-case సింటాక్స్ & అనాటమీ: switch, case, break, default కీవర్డ్స్.
• CPU లెవల్ Jump Tables: else-if కంటే switch ఎందుకు 10 రెట్లు వేగవంతమైనది? అసెంబ్లీ లెవల్ విశ్లేషణ.
• break స్టేట్‌మెంట్ పాత్ర: కంట్రోల్ ఫ్లోను వెంటనే switch నుండి బయటకు పంపే విధానం.
• ఫాల్-త్రూ (Fall-Through) మెకానిక్స్: బ్రేక్ లేకపోతే ఏం జరుగుతుంది? దీనిని తెలివిగా ఎలా వాడాలి?
• default కేస్ ప్రాధాన్యత: యూజర్ తప్పుడు ఆప్షన్ ఇచ్చినప్పుడు ఫాల్‌బ్యాక్ సేఫ్టీ గార్డ్.
• C లో switch కఠిన నియమాలు: ఫ్లోట్స్ (float) మరియు స్ట్రింగ్స్ ఎందుకు పనిచేయవు?
• మెనూ డ్రివెన్ ప్రోగ్రామింగ్ (Menu-Driven Architecture): ప్రాక్టికల్ కన్సోల్ అప్లికేషన్లు.
• రియల్ వరల్డ్ ప్రాజెక్ట్: పూర్తి స్థాయి అరిథ్‌మెటిక్ క్యాలిక్యులేటర్ నిర్మాణం.
• నెస్టెడ్ switch స్టేట్‌మెంట్స్: మెనూ లోపల సబ్-మెనూలను ఎలా హ్యాండిల్ చేయాలి?
• బిగినర్స్ చేసే టాప్ 5 తప్పులు: డూప్లికేట్ కేస్‌లు, కేస్ లోపల వేరియబుల్ డిక్లరేషన్ ట్రాప్.
• ఇంటరాక్టివ్ క్విజ్: 5 లోతైన ప్రాక్టికల్ ప్రశ్నలు & విశ్లేషణ.

మనం కస్టమర్ కేర్‌కు ఫోన్ చేసినప్పుడు కంప్యూటర్ స్వరం వినిపిస్తుంది: "తెలుగు కోసం 1 నొక్కండి, ఇంగ్లీష్ కోసం 2 నొక్కండి, మా ప్రతినిధితో మాట్లాడటానికి 9 నొక్కండి". మీరు '1' ప్రెస్ చేయగానే అది నేరుగా తెలుగు విభాగానికి కనెక్ట్ అవుతుంది. దీనినే మల్టీ-వే సెలెక్షన్ (Multi-Way Selection) అంటారు.

ఒకే వేరియబుల్‌ను అనేక స్థిర విలువలతో (Constants) పోల్చవలసి వచ్చినప్పుడు, పొడవైన else-if లాడర్ రాయడం కోడ్‌ను గజిబిజిగా చేస్తుంది. అటువంటి సందర్భాలలో switch-case కోడ్‌ను అత్యంత శుభ్రంగా, చదవడానికి సులభంగా మరియు వేగవంతంగా మారుస్తుంది.

C లో switch-case యొక్క ప్రామాణిక సింటాక్స్ ఇది:

#include <stdio.h>

int main(void) {
    int dayNumber = 3;

    switch (dayNumber) {
        case 1:
            printf("సోమవారం (Monday) — కొత్త వారం ప్రారంభం!\n");
            break;
        case 2:
            printf("మంగళవారం (Tuesday)\n");
            break;
        case 3:
            printf("బుధవారం (Wednesday) — వారం మధ్య రోజు!\n");
            break;
        case 4:
            printf("గురువారం (Thursday)\n");
            break;
        case 5:
            printf("శుక్రవారం (Friday) — వీకెండ్ మొదలవుతోంది!\n");
            break;
        case 6:
            printf("శనివారం (Saturday) — సెలవు దినం!\n");
            break;
        case 7:
            printf("ఆదివారం (Sunday) — ఫ్యామిలీ టైమ్!\n");
            break;
        default:
            printf("❌ తప్పుడు రోజు నంబర్! దయచేసి 1 నుండి 7 మధ్య ఇవ్వండి.\n");
    }

    return 0;
}

చాలామంది ప్రోగ్రామర్లు "switch చేసే పనిని else-if కూడా చేస్తుంది కదా, అసలు switch ఎందుకు వాడాలి?" అని అడుగుతుంటారు. దీనికి సమాధానం CPU ఆర్కిటెక్చర్ మరియు ఎగ్జిక్యూషన్ వేగం!

break అనేది C లోని ఒక జంప్ కీవర్డ్. ఒక కేస్ కోడ్ ముగిసిన వెంటనే — కంట్రోల్ మిగిలిన కేస్‌లలోకి ప్రవహించకుండా, వెంటనే మొత్తం switch { ... } బ్లాక్ నుండి బయటకు విసిరివేయడానికి break తప్పనిసరి!

ఒకవేళ మీరు పొరపాటున break రాయడం మర్చిపోతే — కంపైలర్ తర్వాతి కేస్‌లను మ్యాచ్ అయ్యాయో లేదో కూడా చూడకుండా అన్నింటినీ ఒకదాని తర్వాత ఒకటి గుడ్డిగా ఎగ్జిక్యూట్ చేసుకుంటూ వెళ్ళిపోతుంది! దీనినే Fall-Through అంటారు.

ఫాల్-త్రూ అనేది సాధారణంగా ఒక బగ్ అయినప్పటికీ — సీనియర్ ప్రోగ్రామర్లు దీనిని ఒక శక్తివంతమైన ఫీచర్‌గా మార్చుకుంటారు! అనేక వేర్వేరు కేస్‌లకు ఒకే కోడ్ ఎగ్జిక్యూట్ కావాల్సి వచ్చినప్పుడు మధ్యలో break రాయకుండా వదిలేస్తారు:

#include <stdio.h>

int main(void) {
    char ch = 'E';

    printf("అక్షరం: %c\n", ch);

    // a, e, i, o, u లన్నింటికీ ఒకే లాజిక్ రన్ చేయడానికి ఫాల్-త్రూ టెక్నిక్!
    switch (ch) {
        case 'a':
        case 'A':
        case 'e':
        case 'E':
        case 'i':
        case 'I':
        case 'o':
        case 'O':
        case 'u':
        case 'U':
            printf("✅ ఇది అచ్చు (Vowel)!\n");
            break; // ఇక్కడ మాత్రమే బ్రేక్ ఉంది!
        default:
            printf("🔤 ఇది హల్లు (Consonant) లేదా ప్రత్యేక చిహ్నం.\n");
    }

    return 0;
}

పై కోడ్‌లో 10 వేర్వేరు if (ch == 'a' || ch == 'A' ...) కండిషన్లు రాయకుండా, కేవలం కేస్‌లను వరుసగా పేర్చి ఒకే ఒక break తో పని పూర్తి చేశాం!

default అనేది if-else లాడర్‌లోని చివరి else లాంటిది. యూజర్ ఇచ్చిన విలువ పైన పేర్కొన్న ఏ ఒక్క కేస్‌తోనూ మ్యాచ్ కానప్పుడు ఈ default బ్లాక్ ఎగ్జిక్యూట్ అవుతుంది.

• default రాయడం ఆప్షనల్ (తప్పనిసరి కాదు), కానీ ప్రొఫెషనల్ కోడింగ్‌లో ఊహించని యూజర్ తప్పులను కనిపెట్టడానికి ఇది ఖచ్చితంగా ఉండాలి.
• సాధారణంగా default ను switch చివరలో ఉంచుతారు; అయితే దీనిని switch లోపల ఎక్కడైనా ఉంచవచ్చు.
• చివరలో ఉన్న default కు break రాయకపోయినా నడుస్తుంది, కానీ రాయడం మంచి ప్రోగ్రామింగ్ అలవాటు.

C లాంగ్వేజ్‌లో switch స్టేట్‌మెంట్‌కు కొన్ని కఠినమైన ఆర్కిటెక్చరల్ పరిమితులు ఉన్నాయి. వీటిని ఉల్లంఘిస్తే కంపైలర్ కోడ్‌ను అస్సలు అంగీకరించదు:

యూజర్ ఒక ఆపరేషన్‌ను ఎంచుకోవడానికి మరియు దాని ప్రకారం గణిత చర్యలు జరపడానికి switch స్టేట్‌మెంట్‌తో ఒక పూర్తి స్థాయి మెనూ-డ్రివెన్ క్యాలిక్యులేటర్ ప్రోగ్రామ్‌ను నిర్మిద్దాం:

#include <stdio.h>

int main(void) {
    char operator;
    double num1, num2, result;

    printf("=== మన సింపుల్ క్యాలిక్యులేటర్ ===\n");
    printf("ఆపరేటర్‌ను ఎంచుకోండి (+, -, *, /): ");
    scanf(" %c", &operator); // బఫర్ సమస్య రాకుండా స్పేస్ ఉంచాం!

    printf("రెండు సంఖ్యలను నమోదు చేయండి: ");
    scanf("%lf %lf", &num1, &num2);

    switch (operator) {
        case '+':
            result = num1 + num2;
            printf("ఫలితం: %.2lf + %.2lf = %.2lf\n", num1, num2, result);
            break;

        case '-':
            result = num1 - num2;
            printf("ఫలితం: %.2lf - %.2lf = %.2lf\n", num1, num2, result);
            break;

        case '*':
            result = num1 * num2;
            printf("ఫలితం: %.2lf * %.2lf = %.2lf\n", num1, num2, result);
            break;

        case '/':
            // సున్నాతో భాగాహారం (Division by Zero) నిరోధించడం
            if (num2 == 0) {
                printf("❌ ఎర్రర్: గణితంలో సున్నా (0) తో భాగాహారం అసాధ్యం!\n");
            } else {
                result = num1 / num2;
                printf("ఫలితం: %.2lf / %.2lf = %.2lf\n", num1, num2, result);
            }
            break;

        default:
            printf("❌ చెల్లని ఆపరేటర్! దయచేసి +, -, *, / లలో ఒకటి ఎంచుకోండి.\n");
    }

    return 0;
}

ఒక case బ్లాక్ లోపల మరొక switch స్టేట్‌మెంట్‌ను రాయడాన్ని నెస్టెడ్ switch అంటారు. ఉదాహరణకు ఒక కాలేజీలో విభాగం (Department: CSE, ECE) ఎంచుకున్న తర్వాత — ఆ విభాగంలోని ఇయర్ (1st Year, 2nd Year) ఎంచుకోవడానికి ఇది ఉపయోగపడుతుంది:

#include <stdio.h>

int main(void) {
    int deptCode = 1; // 1 = CSE, 2 = ECE
    int year = 2;

    switch (deptCode) {
        case 1:
            printf("విభాగం: కంప్యూటర్ సైన్స్ (CSE)\n");
            // CSE లోపల ఇయర్ సబ్-మెనూ
            switch (year) {
                case 1:
                    printf("సబ్జెక్ట్: C ప్రోగ్రామింగ్ & ఇంజనీరింగ్ ఫిజిక్స్\n");
                    break;
                case 2:
                    printf("సబ్జెక్ట్: డేటా స్ట్రక్చర్స్ & డిజిటల్ లాజిక్\n");
                    break;
                default:
                    printf("ఇతర సంవత్సరాలు.\n");
            }
            break;

        case 2:
            printf("విభాగం: ఎలక్ట్రానిక్స్ (ECE)\n");
            break;

        default:
            printf("తెలియని విభాగం!\n");
    }

    return 0;
}

ఈ ఆరవ అధ్యాయంలో మీరు నేర్చుకున్న switch-case భావనలను పరీక్షించుకోవడానికి క్రింది ప్రశ్నలపై క్లిక్ చేయండి: