משפט switch ב-C++: case, fall-through ו-break

בשביל מה switch

switch משווה ערך אחד מול רשימה של אפשרויות קבועות ומריץ את הענף שמתאים. כשאתם מוצאים את עצמכם כותבים שרשרת ארוכה של if/else if שבודקת שוב ושוב את אותו משתנה מול קבועים שונים, switch מבטא את הכוונה בצורה ברורה יותר, ולעיתים קרובות מתקמפל לטבלת קפיצות מהירה יותר.

הוא בודק רק שוויון מול קבועים בזמן קומפילציה, על ערך מטיפוס שלם. הוא לא יכול לבדוק טווחים, להשוות מחרוזות או לשלב תנאים. לכל אלה, הישארו עם if/else.

switch בסיסי

נותנים ל-switch ערך, ואז רושמים תוויות case לערכים שמעניינים אתכם. כל ענף מסתיים ב-break:

#include <iostream>
using namespace std;

int main() {
    int day = 3;

    switch (day) {
        case 1:
            cout << "Monday" << endl;
            break;
        case 2:
            cout << "Tuesday" << endl;
            break;
        case 3:
            cout << "Wednesday" << endl;
            break;
        default:
            cout << "Some other day" << endl;
            break;
    }

    return 0;
}

הערך 3 מתאים ל-case 3:, אז "Wednesday" מודפס ו-break קופץ החוצה מה-switch. ענף ה-default תופס את כל השאר: הוא רץ כשאף case לא מתאים. הוא אופציונלי, אבל כדאי לכלול אותו אלא אם אתם בטוחים שכל ערך מטופל.

שימו לב שתוויות ה-case הן קבועים חשופים ואחריהם נקודתיים, לא תנאים. כותבים case 3:, אף פעם לא case day == 3:.

break ו-fall-through

זו המלכודת החשובה ביותר של switch ב-C++. אחרי ש-case מתאים, הביצוע לא עוצר ב-case הבא: הוא ממשיך לרוץ ישר עד שהוא פוגש break או את הסוגר המסולסל הסוגר. שימו לב מה קורה כשמשפטי ה-break חסרים:

#include <iostream>
using namespace std;

int main() {
    int level = 1;

    switch (level) {
        case 1:
            cout << "one" << endl;
        case 2:
            cout << "two" << endl;
        case 3:
            cout << "three" << endl;
        default:
            cout << "done" << endl;
    }

    return 0;
}

אולי ציפיתם רק ל-"one". במקום זה כל ארבע השורות מודפסות: ההתאמה ל-case 1: נכנסת ל-switch שם ואז נופלת (falls through) דרך כל התוויות שמתחתיה. הוסיפו break; אחרי כל ענף ותקבלו את השורה היחידה שרציתם. שכחה של break היא המקור הקלאסי לבאגים מסוג "למה ה-switch שלי מריץ יותר מדי קוד?".

fall-through מכוון לקיבוץ מקרים

fall-through הוא לא תמיד טעות: זו הדרך האידיומטית לגרום לכמה מקרים לחלוק גוף אחד. השאירו את ה-cases ריקים (בלי משפטים, בלי break) וכולם יזרמו לבלוק הבא:

#include <iostream>
using namespace std;

int main() {
    char grade = 'B';

    switch (grade) {
        case 'A':
        case 'B':
        case 'C':
            cout << "Pass" << endl;
            break;
        case 'D':
        case 'F':
            cout << "Fail" << endl;
            break;
        default:
            cout << "Invalid grade" << endl;
    }

    return 0;
}

'A', 'B' ו-'C' מגיעים כולם לאותה שורת "Pass", כי שני ה-cases הראשונים ריקים ונופלים לשלישי. זה נקי ומכוון. כשאתם כן מתכוונים ליפול הלאה אחרי שהרצתם קוד, תעדו את זה בהערה, או ב-C++17 ומעלה השתמשו בתכונה [[fallthrough]];, שאומרת למהדר "כן, התכוונתי לזה" ומשתיקה אזהרות fall-through.

switch על enums

switch משתלב באופן טבעי עם enums, כי enum הוא בדיוק "אחד מתוך קבוצה קבועה של ערכים". המהדרים גם יכולים להזהיר אתכם אם שכחתם לטפל באחד הערכים:

#include <iostream>
using namespace std;

enum class Direction { North, East, South, West };

int main() {
    Direction d = Direction::East;

    switch (d) {
        case Direction::North:
            cout << "Heading up" << endl;
            break;
        case Direction::East:
            cout << "Heading right" << endl;
            break;
        case Direction::South:
            cout << "Heading down" << endl;
            break;
        case Direction::West:
            cout << "Heading left" << endl;
            break;
    }

    return 0;
}

עם enum class בעל scope חייבים להוסיף את שם הטיפוס לכל תווית (Direction::East). מכיוון שכל ערך מכוסה, אין צורך ב-default, ומהדרים רבים יזהירו אם בהמשך תוסיפו כיוון חמישי ותשכחו להוסיף לו case. העזרה הזו מהמהדר היא סיבה גדולה להעדיף switch על פני שרשראות if/else כשעובדים עם enums.

מלכודת: הצהרות בתוך case

אי אפשר להצהיר על משתנה עם ערך התחלתי ב-case אחד ולגרום לו להיות נגיש בשאר ה-cases בלי לתחום אותו. זו שגיאת קומפילציה נפוצה:

switch (x) {
    case 1:
        int n = 10;   // שגיאה: הקפיצה ל-case 2 מדלגת על האתחול הזה
        cout << n;
        break;
    case 2:
        cout << "two";
        break;
}

המהדר דוחה את זה כי נפילה ל-case 2: הייתה מדלגת על האתחול של n בזמן ש-n עדיין בטווח ההכרה. הפתרון הוא לעטוף את גוף ה-case בסוגריים מסולסלים משלו, וכך המשתנה מקבל בלוק משלו:

#include <iostream>
using namespace std;

int main() {
    int x = 1;

    switch (x) {
        case 1: {
            int n = 10;   // עכשיו תחום לבלוק הזה, תקין
            cout << n << endl;
            break;
        }
        case 2:
            cout << "two" << endl;
            break;
    }

    return 0;
}

בכל פעם ש-case צריך משתנה מקומי משלו, תנו לו סוגריים מסולסלים. זה גם מונע מהמשתנה לדלוף ל-cases שמתחתיו.

הבא בתור: לולאת for

switch ו-if מאפשרים לתוכנית לבחור איזה קוד להריץ פעם אחת. אבל הרבה עבודה פירושה לעשות את אותו דבר הרבה פעמים: לספור, לעבור על רשימה, לחזור עד שתנאי משתנה. לולאת for היא סוס העבודה לזה, והיא הדף הבא.