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

למה תוכניות צריכות הסתעפויות

כל תוכנית עד עכשיו רצה ישר: שורה 1, שורה 2, שורה 3. תוכניות אמיתיות מקבלות החלטות. האם הסיסמה נכונה? האם המספר שלילי? האם הקובץ נפתח? פקודת if היא הדרך של C לשאול שאלה ולהריץ קוד רק כשהתשובה היא כן.

#include <stdio.h>

int main(void) {
    int temperature = 31;

    if (temperature > 30) {
        printf("It is hot today.\n");
    }

    printf("Have a good day.\n");
    return 0;
}

התנאי temperature > 30 נבדק פעם אחת. הוא מתקיים, ולכן ההודעה מודפסת. השורה האחרונה נמצאת מחוץ לסוגריים המסולסלים, ולכן היא מודפסת בכל מקרה. שנו את 31 ל-18 והריצו שוב: ההודעה הראשונה נעלמת והשנייה נשארת.

תחביר: סוגריים, סוגריים מסולסלים ובלי נקודה-פסיק

ל-if ב-C יש צורה קבועה:

if (condition) {
    // רץ כשהתנאי שונה מאפס
}

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

// באג: ה-if לא עושה כלום; ה-printf תמיד רץ
if (x > 10);
{
    printf("big\n");
}

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

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

else ו-else if

else מספק את המסלול השני:

#include <stdio.h>

int main(void) {
    int score = 47;

    if (score >= 60) {
        printf("Pass\n");
    } else {
        printf("Fail\n");
    }

    return 0;
}

עבור יותר משתי תוצאות, שרשרו עם else if. C בודקת כל תנאי לפי הסדר ועוצרת בראשון שמתקיים:

#include <stdio.h>

int main(void) {
    int score = 84;

    if (score >= 90) {
        printf("Grade: A\n");
    } else if (score >= 80) {
        printf("Grade: B\n");
    } else if (score >= 70) {
        printf("Grade: C\n");
    } else {
        printf("Grade: F\n");
    }

    return 0;
}

הסדר חשוב כאן מאוד. מכיוון שהשרשרת עוצרת בהתאמה הראשונה, הבדיקה השנייה רואה רק ציונים מתחת ל-90, ולכן score >= 80 לא צריך להוסיף גם && score < 90. כתבו את השרשרת מהתנאי המחמיר ביותר לפחות מחמיר, אחרת כל ערך ייפול לענף הראשון.

ה-else בסוף אופציונלי. הוסיפו אותו בכל פעם שהשרשרת אמורה לכסות כל מקרה; היעדרו פירושו "אם שום דבר לא התאים, לא לעשות כלום", וזה בסדר, אבל צריך להיות מכוון.

ערכי אמת: 0 הוא שקר, כל השאר אמת

בשפה הבסיסית של C אין טיפוס בוליאני נפרד בתנאים. if פשוט שואל אם הביטוי שונה מאפס.

#include <stdio.h>

int main(void) {
    int count = 3;
    int empty = 0;

    if (count) {
        printf("count is nonzero: %d\n", count);
    }

    if (!empty) {
        printf("empty is zero, so !empty is true\n");
    }

    printf("(5 > 2) evaluates to %d\n", 5 > 2);
    printf("(5 < 2) evaluates to %d\n", 5 < 2);
    return 0;
}

שתי השורות האחרונות מראות את החצי השני של הכלל: אופרטורי השוואה הם ביטויים רגילים שמפיקים 1 עבור אמת ו-0 עבור שקר. בגלל זה if (5 > 2) עובד: זה בעצם if (1).

זו גם הסיבה ש--3 הוא אמת ב-C. הכלל הוא שונה מאפס, לא חיובי. אם אתם רוצים לדעת אם מספר חיובי, כתבו if (n > 0), לא if (n).

C99 הוסיפה את <stdbool.h> עם טיפוס bool אמיתי ועם true ו-false, שנקראים טוב יותר בקוד חדש. מתחת למכסה הם עדיין 1 ו-0, כך ששום דבר בכלל שלמעלה לא משתנה. ראו את העמוד על בוליאנים ב-C.

אופרטורי ההשוואה והאופרטורים הלוגיים שתשתמשו בהם בתנאים:

==   equal to            &&   logical AND (both sides true)
!=   not equal to        ||   logical OR  (either side true)
<    less than           !    logical NOT
>    greater than
<=   less than or equal
>=   greater than or equal

&& ו-|| מבצעים short-circuit: a && b אף פעם לא מחשב את b אם a שקר, ו-a || b אף פעם לא מחשב את b אם a אמת. זו הבטחה, לא אופטימיזציה, ולכן בטוח לכתוב if (n != 0 && total / n > 5): החילוק לא יכול לרוץ כש-n הוא אפס.

הבאג של = מול ==

זו הטעות הנפוצה ביותר בתנאים ב-C:

// באג: משים 5 ל-x, ואז בודק 5 (שונה מאפס), אז זה תמיד רץ
if (x = 5) {
    printf("x is five\n");
}

C מאפשרת השמה בתוך ביטוי, ולכן השורה חוקית. היא שומרת 5 ב-x, מפיקה את הערך 5, ו-5 אינו אפס: הענף רץ בכל פעם, ו-x נדרס בשקט.

שתי הגנות. ראשית, תמיד קמפלו עם אזהרות:

gcc -Wall -Wextra program.c -o program

גם GCC וגם clang מסמנים "suggest parentheses around assignment used as truth value". שנית, יש מתכנתים שכותבים את הקבוע לפני המשתנה, if (5 == x), כך ששגיאת הקלדה כמו if (5 = x) תהיה שגיאת קומפילציה ולא באג שקט. הסגנון הזה עניין של טעם; הפעלת אזהרות לא.

קינון

if יכול להכיל if אחר. קינון מבטא תנאים שיש להם משמעות רק אחרי שתנאי קודם מתקיים:

#include <stdio.h>

int main(void) {
    int age = 22;
    int hasTicket = 1;

    if (age >= 18) {
        if (hasTicket) {
            printf("Welcome in.\n");
        } else {
            printf("Please buy a ticket.\n");
        }
    } else {
        printf("Adults only.\n");
    }

    return 0;
}

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

// שטוח יותר: מטפלים בחריגים, ואז ממשיכים בעבודה
if (age < 18)     { printf("Adults only.\n");        return 0; }
if (!hasTicket)   { printf("Please buy a ticket.\n"); return 0; }
printf("Welcome in.\n");

ה-else התלוי

כש-if בלי סוגריים מסולסלים מקונן בתוך if אחר, לאיזה if שייך ה-else? הכלל של C: else נקשר ל-if הקרוב ביותר שעוד לא הותאם, בלי קשר לאיך שהקוד מוזח.

// ה-else שייך ל-if הפנימי, למרות ההזחה
if (a > 0)
    if (b > 0)
        printf("both positive\n");
else
    printf("a is not positive\n");   // שגוי: רץ כש-a > 0 ו-b <= 0

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

if (a > 0) {
    if (b > 0) {
        printf("both positive\n");
    }
} else {
    printf("a is not positive\n");
}

האופרטור הטרנרי

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

#include <stdio.h>

int main(void) {
    int a = 17, b = 42;

    int max = (a > b) ? a : b;
    printf("Larger: %d\n", max);

    /* זה ביטוי, אז הוא יכול לשבת בתוך printf */
    printf("%d is %s\n", a, (a % 2 == 0) ? "even" : "odd");

    return 0;
}

קראו את cond ? x : y כ"אם cond אז x, אחרת y". רק אחד משני הענפים מחושב, וכל הביטוי מפיק ערך, ולכן אפשר להשים אותו או להעביר אותו כארגומנט במקום שבו פקודה לא יכולה להופיע.

שמרו אותו לבחירות פשוטות של ערכים. אופרטורים טרנריים מקוננים (a ? b : c ? d : e) חוקיים וכמעט תמיד קשים יותר לקריאה משרשרת ה-else if שהם מחליפים.