לולאת for ב-C: תחביר, דוגמאות וטעויות נפוצות

למה לולאת for

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

כל מה שלולאת for צריכה יושב בכותרת קומפקטית אחת, כך ש"כמה פעמים, ואיך" גלוי בשורה אחת.

#include <stdio.h>

int main(void) {
    for (int i = 0; i < 5; i++) {
        printf("i = %d\n", i);
    }
    printf("done\n");
    return 0;
}

הכותרת בת שלושת החלקים

לכותרת של for יש שלושה חלקים שמופרדים בנקודה ופסיק: מאתחל, תנאי ועדכון.

for (initializer; condition; update) {
    // body - runs while the condition is nonzero
}

הם רצים בסדר מסוים, והיכרות איתו מסבירה כל לולאת for שתקראו אי פעם:

1. המאתחל רץ פעם אחת, לפני כל דבר אחר.
2. התנאי נבדק. אם הוא אפס, הלולאה מסתיימת מיד.
3. הגוף רץ.
4. העדכון רץ.
5. חזרה לשלב 2.

עקבו אחרי הלולאה שלמעלה עם הרשימה הזו: int i = 0 רץ פעם אחת. 0 < 5 מתקיים, אז הגוף מדפיס i = 0, ואז i++ הופך את i ל-1. התנאי נבדק שוב, וכן הלאה. כש-i מגיע ל-5 הבדיקה נכשלת, מדלגים על הגוף, ו-done מודפס. הגוף רץ בדיוק חמש פעמים, כש-i מקבל את הערכים 0 עד 4.

שתי השלכות נובעות מזה ישירות. התנאי נבדק לפני הסיבוב הראשון, כך שלולאה שהתנאי שלה מתחיל כשקר רצה אפס פעמים: for (int i = 10; i < 5; i++) אף פעם לא נכנסת לגוף. והעדכון רץ אחרי הגוף, כך ש-i עדיין מחזיק את הערך הישן לאורך כל הגוף.

הצהרה על המונה בתוך הכותרת (int i = 0) חוקית מאז C99 והיא ברירת המחדל הנכונה: i קיים אז רק בתוך הלולאה, כך שהוא לא יכול להתנגש בשום דבר שאחריה, וכל לולאה בפונקציה יכולה להשתמש שוב באותו שם בחופשיות.

ספירה למעלה, למטה ובקפיצות

העדכון לא מוגבל ל-i++. אפשר לספור למטה, לקפוץ בכל גודל או להכפיל בכל סיבוב:

#include <stdio.h>

int main(void) {
    /* count down */
    for (int i = 5; i > 0; i--) {
        printf("%d ", i);
    }
    printf("liftoff\n");

    /* step by 2 */
    for (int n = 0; n <= 10; n += 2) {
        printf("%d ", n);
    }
    printf("\n");

    /* multiply instead of add */
    for (int p = 1; p <= 64; p *= 2) {
        printf("%d ", p);
    }
    printf("\n");

    return 0;
}

התאימו את התנאי לעדכון. ספירה למעלה הולכת עם < או <=; ספירה למטה הולכת עם > או >=. טעות בזיווג הזה היא הדרך לכתוב לולאה שלעולם לא נגמרת.

שימו לב שהלולאה השנייה משתמשת ב-<= 10 כי 10 הוא ערך שרוצים לכלול, בעוד שהדוגמה הראשונה השתמשה ב-< 5 כי 5 לא. הבחירה הזו היא המקום שבו נולדים באגים של טעות באחד, אז עשו אותה במודע: i < n רצה n פעמים החל מ-0; i <= n רצה n + 1 פעמים.

מעבר על מערך

השימוש הנפוץ ביותר בלולאת ספירה הוא מעבר על מערך לפי אינדקס. המונה משמש גם כמיקום שקוראים ממנו.

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 60, 100};
    int n = sizeof(scores) / sizeof(scores[0]);

    int total = 0;
    for (int i = 0; i < n; i++) {
        printf("scores[%d] = %d\n", i, scores[i]);
        total += scores[i];
    }

    printf("Sum: %d\n", total);
    printf("Average: %.1f\n", (double) total / n);
    return 0;
}

שני דברים לקחת מהדוגמה הזו.

טריק ה-sizeof. sizeof(scores) הוא הגודל של כל המערך בבתים, ו-sizeof(scores[0]) הוא הגודל של איבר אחד, כך שהמנה שלהם היא מספר האיברים. זה מתעדכן אוטומטית כשמוסיפים איבר, משהו ש-5 קבוע בקוד לא עושה. המלכודת, והיא גדולה, היא שזה עובד רק במקום שבו המערך עצמו נמצא בטווח. העבירו את המערך לפונקציה והוא הופך למצביע, כך ש-sizeof שם נותן את הגודל של מצביע במקום. בתוך פונקציה, תמיד קבלו את האורך כפרמטר נפרד.

התנאי הוא i < n, אף פעם לא i <= n. למערך של חמישה איברים יש אינדקסים חוקיים 0 עד 4. קריאת scores[5] היא התנהגות לא מוגדרת: היא עלולה להדפיס זבל, לקרוס, או להיראות תקינה בזמן שהיא משחיתה בשקט משהו אחר. C לא בודקת גבולות בכלל, אז זה לגמרי באחריותכם.

מעבר על מערך מהסוף להתחלה הוא אותו רעיון בכיוון ההפוך:

#include <stdio.h>

int main(void) {
    int a[] = {10, 20, 30, 40, 50};
    int n = sizeof(a) / sizeof(a[0]);

    for (int i = n - 1; i >= 0; i--) {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

מתחילים ב-n - 1 (האינדקס החוקי האחרון), עוצרים ב-0 כולל, ולכן >= ולא >. השאירו את i כ-int עם סימן כאן; הסעיף הבא מסביר למה.

לולאות מקוננות

שימו for אחת בתוך אחרת כדי לעבוד עם רשתות, טבלאות או כל זוג של פריטים. הלולאה הפנימית רצה עד הסוף עבור כל צעד יחיד של הלולאה החיצונית.

#include <stdio.h>

int main(void) {
    for (int row = 1; row <= 5; row++) {
        for (int col = 1; col <= 5; col++) {
            printf("%4d", row * col);
        }
        printf("\n");
    }
    return 0;
}

הלולאה החיצונית קובעת row; הלולאה הפנימית עוברת על כל col עבור השורה הזו; ה-printf("\n") שאחרי הלולאה הפנימית מסיים את השורה. העבירו את השורה החדשה הזו לתוך הלולאה הפנימית וכל הטבלה הופכת לעמודה אחת, וזה ניסוי שימושי, כי הוא הופך את מבנה הקינון למוחשי.

תנו למונים שמות שונים. row/col או i/j בסדר; שימוש חוזר ב-i לשניהם מסתיר את המונה החיצוני ומייצר תוצאות מבלבלות. ושימו לב לעלות: לולאה של n בתוך לולאה של n מריצה את הגוף n * n פעמים, כך שזוג לולאות של 1,000 איטרציות הן מיליון סיבובים.

הנה לולאה מקוננת שעושה עבודה אמיתית: משולש של כוכביות, שבו הגבול של הלולאה הפנימית תלוי במונה החיצוני:

#include <stdio.h>

int main(void) {
    int height = 5;

    for (int row = 1; row <= height; row++) {
        for (int star = 0; star < row; star++) {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

break ו-continue

שתי מילות מפתח משנות את הזרימה באמצע הלולאה. break יוצאת מהלולאה מיד; continue מדלגת על שאר הסיבוב הנוכחי וקופצת לעדכון.

#include <stdio.h>

int main(void) {
    /* stop at the first multiple of 7 */
    for (int i = 1; i <= 100; i++) {
        if (i % 7 == 0) {
            printf("First multiple of 7: %d\n", i);
            break;
        }
    }

    /* print only the odd numbers */
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            continue;
        }
        printf("%d ", i);
    }
    printf("\n");

    return 0;
}

הלולאה הראשונה עוצרת ברגע שהיא מוצאת את 7 ואף פעם לא בודקת את 93 הערכים הנותרים. השנייה משתמשת ב-continue כדי לדלג על ההדפסה של מספרים זוגיים; ה-i++ שבכותרת עדיין רץ, כך שהלולאה ממשיכה להתקדם. יש הרבה יותר על שתיהן בעמוד על break ו-continue, כולל איך יוצאים מלולאה מקוננת, משהו ש-break יחידה לא יכולה לעשות.

לולאות אינסופיות וחלקים ריקים

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

for (;;) {
    /* runs forever - exit with break or return */
}

for (;;) היא הלולאה האינסופית המקובלת ב-C, וסימני הנקודה ופסיק עדיין נדרשים. זו לא טעות כל עוד משהו בפנים יכול לעשות break, return או exit: לולאות אירועים ולולאות של "תמשיך לשאול עד שהקלט תקין" נכתבות בדיוק כך.

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

int i = 0;
for (; i < n; ) {
    /* ... */
    i += step;
}

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

אופרטור הפסיק בכותרת

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

#include <stdio.h>

int isPalindrome(const char *word) {
    int len = 0;
    while (word[len] != '\0') {
        len++;
    }

    /* walk inward from both ends at once */
    for (int i = 0, j = len - 1; i < j; i++, j--) {
        if (word[i] != word[j]) {
            return 0;
        }
    }
    return 1;
}

int main(void) {
    const char *words[] = {"racecar", "level", "stressed"};

    for (int w = 0; w < 3; w++) {
        printf("\"%s\" is %sa palindrome\n",
               words[w], isPalindrome(words[w]) ? "" : "not ");
    }
    return 0;
}

int i = 0, j = len - 1 מצהיר על שני המונים, ו-i++, j-- מקדם את שניהם. זה אופרטור הפסיק, שמחשב את האופרנדים שלו לפי הסדר. השתמשו בו למונים שבאמת מקבילים; דחיסה של עבודה לא קשורה לכותרת רק מסתירה אותה.

מלכודות נפוצות

קומץ מלכודות אחראי לרוב הבאגים של לולאות for ב-C.

טעות באחד. i <= n על מערך שמתחיל מאפס קורא איבר אחד מעבר לסוף. השתמשו ב-i < n עבור "n פעמים החל מ-0".

נקודה ופסיק אחרי הכותרת. זה מתקמפל וכמעט אף פעם אינו מה שהתכוונתם:

/* BUG: the loop body is the empty statement; the printf runs once */
for (int i = 0; i < 5; i++);
{
    printf("%d\n", i);
}

ה-; הופך לגוף, כך שהלולאה מסתובבת חמש פעמים בלי לעשות כלום והסוגריים המסולסלים שמתחת רצים פעם אחת כבלוק רגיל. gcc -Wall מזהיר על זה.

מונים unsigned שסופרים למטה. זו לולאה אינסופית:

/* BUG: an unsigned value is never < 0 */
for (size_t i = n - 1; i >= 0; i--) {
    process(a[i]);
}

i >= 0 תמיד אמת לטיפוס בלי סימן. כש-i מגיע ל-0, i-- מתגלגל למספר חיובי ענק והלולאה ממשיכה לתוך זיכרון שאינו שלה. השתמשו ב-int עם סימן לספירה למטה, או כתבו את התנאי כ-for (size_t i = n; i-- > 0; ), שמקטין ובודק בצעד אחד ועוצר נכון באפס.

שינוי המונה בשני מקומות. שינוי של i בתוך הגוף וגם בכותרת הופך את מספר האיטרציות לבלתי צפוי. בחרו מקום אחד.

מונים של נקודה צפה. for (double x = 0.0; x != 1.0; x += 0.1) עלולה לעולם לא להסתיים, כי ל-0.1 אין ייצוג בינארי מדויק והסכום עובר את 1.0 בלי לפגוע בו. עברו בלולאה עם ספירה שלמה וחשבו את הערך בפנים:

for (int i = 0; i <= 10; i++) {
    double x = i / 10.0;
    /* ... */
}

שינוי אורך המערך תוך כדי מעבר עליו. התנאי i < n קורא את n מחדש בכל סיבוב, כך שאם הגוף מקטין את האוסף, התאימו את האינדקס במכוון במקום לתת לשניהם להתרחק זה מזה.