break ו-continue ב-C: איך הן עובדות ומתי להשתמש בהן

שתי דרכים לשנות את מהלך הלולאה

התנאי של לולאה קובע מתי היא נגמרת, אבל לפעמים התשובה האמיתית מתגלה באמצע הגוף. אתם מחפשים במערך ומוצאים את הפריט באיבר השלישי: למה לבדוק את 997 האחרים? או שאתם מעבדים רשימה ורשומה אחת ריקה: מדלגים עליה וממשיכים.

ל-C יש מילת מפתח אחת לכל מקרה:

• break: צאו מהלולאה עכשיו. הביצוע ממשיך בפקודה הראשונה שאחריה.
• continue: נטשו רק את הסיבוב הזה. המשיכו לסיבוב הבא.

#include <stdio.h>

int main(void) {
    printf("break at 5:    ");
    for (int i = 1; i <= 10; i++) {
        if (i == 5) {
            break;
        }
        printf("%d ", i);
    }
    printf("\n");

    printf("continue at 5: ");
    for (int i = 1; i <= 10; i++) {
        if (i == 5) {
            continue;
        }
        printf("%d ", i);
    }
    printf("\n");

    return 0;
}

הלולאה הראשונה מדפיסה 1 2 3 4 ועוצרת. השנייה מדפיסה 1 2 3 4 6 7 8 9 10: היא דילגה על ערך אחד והמשיכה.

break בלולאה

השימוש הקלאסי הוא חיפוש שעוצר ברגע שהוא מצליח:

#include <stdio.h>

int main(void) {
    int data[] = {14, 3, 88, 27, 5, 62};
    int n = sizeof(data) / sizeof(data[0]);
    int target = 27;
    int found = -1;

    for (int i = 0; i < n; i++) {
        if (data[i] == target) {
            found = i;
            break;              /* no reason to look at the rest */
        }
    }

    if (found >= 0) {
        printf("Found %d at index %d\n", target, found);
    } else {
        printf("%d is not in the array\n", target);
    }

    return 0;
}

מכיוון ש-found מקבל ערך לפני ה-break, הקוד שאחרי הלולאה יכול להבחין בין "מצאתי" לבין "נגמרו האיברים". הצמד הזה, משתנה תוצאה ועוד break, הוא ניב החיפוש המקובל ב-C. אי אפשר להשתמש במונה הלולאה עצמו אחר כך כשהוא מוצהר בכותרת, כי הוא יוצא מהטווח בסוגר המסולסל הסוגר.

break תמיד יוצאת מלולאה אחת: ה-for, while, do-while או switch הקרובים ביותר שעוטפים אותה.

continue בלולאה

continue מיועדת לרשומות שצריך לדלג עליהן במקום לעצור את העבודה:

#include <stdio.h>

int main(void) {
    int values[] = {12, -3, 0, 45, -7, 8};
    int n = sizeof(values) / sizeof(values[0]);
    int sum = 0, counted = 0;

    for (int i = 0; i < n; i++) {
        if (values[i] <= 0) {
            continue;           /* ignore zero and negatives */
        }
        sum += values[i];
        counted++;
    }

    printf("Sum of %d positive values: %d\n", counted, sum);
    return 0;
}

לאן continue קופצת תלוי בסוג הלולאה:

for        -> the update part of the header (so the counter still advances)
while      -> the condition test (nothing else in the body runs)
do-while   -> the condition test at the bottom

ההבדל הזה אינו תיאורטי. בלולאת for, continue לעולם לא יכולה לדלג על הגדלת המונה, כי ההגדלה נמצאת בכותרת. בלולאת while היא יכולה:

/* BUG: continue skips i++, so this hangs at the first even number */
int i = 0;
while (i < 10) {
    if (i % 2 == 0) {
        continue;
    }
    printf("%d ", i);
    i++;
}

או שתעבירו את i++ מעל ה-continue, או שתכתבו את זה כלולאת for, שבה הכותרת הופכת את הטעות לבלתי אפשרית.

break בתוך switch אינה break בלולאה

break מסיימת את הלולאה או את ה-switch הקרובים ביותר שעוטפים אותה, מה שקרוב יותר. שימו switch בתוך לולאה, וכל break בתוכו שייכת ל-switch:

#include <stdio.h>

int main(void) {
    char commands[] = "aabqcc";

    for (int i = 0; commands[i] != '\0'; i++) {
        switch (commands[i]) {
            case 'a':
                printf("add\n");
                break;          /* ends the switch; the loop continues */
            case 'b':
                printf("back\n");
                break;
            case 'q':
                printf("quit requested\n");
                break;          /* also only the switch! */
            default:
                printf("unknown: %c\n", commands[i]);
                break;
        }
    }

    printf("loop finished\n");
    return 0;
}

הפקודה q מדפיסה את ההודעה שלה והלולאה ממשיכה לרוץ עד cc. אם היציאה הייתה אמורה לסיים את הלולאה, ה-break הזו לא עשתה את זה. הפתרונות הם דגל, goto, או העברת הלולאה לפונקציה ושימוש ב-return, וכולם מוצגים בהמשך.

יציאה מלולאות מקוננות

break יחידה יוצאת מרמה אחת. בתוך שתי לולאות מקוננות היא מסיימת רק את הפנימית, והלולאה החיצונית מתחילה את הסיבוב הבא שלה כאילו לא קרה כלום.

#include <stdio.h>

int main(void) {
    int grid[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    /* break leaves only the inner loop - the outer keeps going */
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("inner break at row %d\n", r);
                break;
            }
        }
    }
    printf("(the outer loop ran all 3 rows)\n");
    return 0;
}

ל-C אין break 2 ואין break עם תווית. שלוש אפשרויות כנות:

דגל. נייד, ברור וקצת רועש:

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
    int found = 0;

    for (int r = 0; r < 3 && !found; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("Found 7 at row %d, column %d\n", r, c);
                found = 1;
                break;
            }
        }
    }

    return 0;
}

הדגל מופיע בשני מקומות, בתנאי החיצוני ובהשמה, וזה המחיר. עם שלוש רמות קינון זה נהיה ממש לא נעים.

goto. הקפיצה של C שכולם אוהבים לשנוא, וזה המקרה היחיד שבו מתכנתי C מנוסים משתמשים בה בלי להתנצל:

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};

    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("Found 7 at row %d, column %d\n", r, c);
                goto done;
            }
        }
    }
    printf("not found\n");

done:
    printf("search finished\n");
    return 0;
}

goto קדימה לתווית שנמצאת מיד אחרי הלולאות עושה בדיוק מה ש-break עם תווית היה עושה בשפות אחרות, בשורה אחת ובלי דגל שצריך לשמור מסונכרן. המוניטין של goto נבנה בזכות קפיצות אחורה וקפיצות לאמצע של בלוקים אחרים, שבאמת מייצרות זרימת בקרה בלתי קריאה. קפיצה אחת קדימה מתוך לולאות מקוננות אינה כזו. ליבת Linux משתמשת באותה תבנית עבור מסלולי ניקוי. השתמשו בה בכוונה ובמשורה; אל תתנו לטאבו לדחוף אתכם לחלופה עם שלושה דגלים שקשה יותר לקרוא.

פונקציה ו-return. בדרך כלל התשובה הטובה ביותר, כי חיפוש ראוי לשם:

#include <stdio.h>

/* returns 1 and writes the position when found, 0 otherwise */
int findValue(int grid[3][4], int target, int *outRow, int *outCol) {
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == target) {
                *outRow = r;
                *outCol = c;
                return 1;       /* leaves BOTH loops at once */
            }
        }
    }
    return 0;
}

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
    int row, col;

    if (findValue(grid, 7, &row, &col)) {
        printf("Found 7 at row %d, column %d\n", row, col);
    } else {
        printf("7 is not in the grid\n");
    }

    return 0;
}

return יוצאת מכל הלולאות בפונקציה, לא צריכה דגל ולא תווית, ולקוד החיפוש יש עכשיו שם ואפשר לבדוק אותו בנפרד. כשהקינון עמוק מספיק כדי שהיציאה ממנו תהיה בעיה, זה לרוב רמז שהבלוק רצה להיות פונקציה בכל מקרה.

מתי הן עוזרות ומתי הן מזיקות

break ו-continue מצדיקות את מקומן כשהן מאפשרות ללולאה לומר "המקרה הזה הסתיים" פעם אחת, קרוב לראש הגוף, במקום לעטוף את כל הגוף ב-if. השוו:

/* with continue: the real work is not indented */
for (int i = 0; i < n; i++) {
    if (!isValid(a[i])) continue;
    if (isDuplicate(a[i])) continue;
    process(a[i]);
}

/* without: every guard adds a level */
for (int i = 0; i < n; i++) {
    if (isValid(a[i])) {
        if (!isDuplicate(a[i])) {
            process(a[i]);
        }
    }
}

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

שתי מלכודות קטנות יותר. continue בתוך do-while קופצת לבדיקה שבתחתית, שהיא ממילא הדבר הבא: זה לא מזיק, אבל זה מפתיע אנשים. ו-break מחוץ לכל לולאה או switch היא שגיאת קומפילציה, וזו הטעות היחידה כאן שהקומפיילר תופס בשבילכם.