Boolean ב-C: stdbool.h, _Bool ומה נחשב אמת

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

אפס הוא שקר, כל השאר אמת

אין ערך מיוחד של אמת או שקר בכללי התנאים של C. if, while, for, &&, || ו-! שואלים כולם שאלה אחת בדיוק: האם הערך הזה הוא אפס?

#include <stdio.h>

int main(void) {
    if (1)    printf("1 is true\n");
    if (42)   printf("42 is true\n");
    if (-7)   printf("-7 is true\n");
    if (0.5)  printf("0.5 is true\n");

    if (0)    printf("this never prints\n");
    if (0.0)  printf("nor this\n");

    printf("done\n");
    return 0;
}

מספרים שליליים הם אמת. שברים הם אמת. מצביע שאינו null הוא אמת. רק אפס, בכל טיפוס, הוא שקר.

זו הסיבה שקוד C מלא בניבים שנראים תמציתיים עד שמכירים את הכלל:

if (count)            /* if count is not zero */
if (!count)           /* if count is zero */
if (p)                /* if p is not NULL */
if (!strcmp(a, b))    /* if the strings are equal - strcmp returns 0 for a match */

האחרון מפיל אנשים. strcmp מחזירה 0 כשהמחרוזות זהות, כך ש"שוות" נקרא כמו "לא" בתוך if. לכתוב if (strcmp(a, b) == 0) ברור יותר ועושה בדיוק אותו דבר.

השוואות מחזירות int

השוואה ב-C אינה סוג מיוחד של ביטוי. היא מחושבת ל-int רגיל עם הערך 1 או 0, ואפשר להדפיס אותו, לשמור אותו או לעשות איתו חשבון:

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    int result = (a < b);
    printf("(a < b) is %d\n", result);      /* 1 */
    printf("(a > b) is %d\n", a > b);       /* 0 */
    printf("(a == 5) + (b == 8) = %d\n", (a == 5) + (b == 8));  /* 2 */

    /* Counting with the fact that a comparison is 1 or 0: */
    int scores[] = {45, 78, 92, 60, 88};
    int passed = 0;
    for (int i = 0; i < 5; i++) {
        passed += (scores[i] >= 60);   /* adds 1 when true, 0 when false */
    }
    printf("%d of 5 passed\n", passed);
    return 0;
}

האופרטור ! עובד באותו אופן: הוא מחזיר 1 אם האופרנד שלו הוא אפס ו-0 אחרת. לכן !!x הוא ניב קלאסי שמנרמל כל ערך לבדיוק 0 או 1.

bool, true ו-false (C99)

C99 הוסיפה טיפוס בוליאני אמיתי בשם _Bool, וקובץ כותרת שנותן לו שם קריא:

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    bool is_ready = true;
    bool has_error = false;

    printf("is_ready  = %d\n", is_ready);    /* prints 1 */
    printf("has_error = %d\n", has_error);   /* prints 0 */

    if (is_ready && !has_error) {
        printf("Proceeding.\n");
    }
    return 0;
}

<stdbool.h> זעיר: הוא מגדיר את bool כ-_Bool, את true כ-1 ואת false כ-0. זה כל הקובץ. אבל השימוש בו הופך את הכוונה לגלויה באופן ש-int flag = 1; אף פעם לא עושה.

ל-_Bool יש התנהגות ייחודית אחת באמת: הוא מאחסן רק 0 או 1. השמה של כל ערך שונה מאפס מומרת לבדיוק 1:

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    int    as_int  = 42;
    bool   as_bool = 42;      /* converted to 1 */

    printf("int  holding 42: %d\n", as_int);
    printf("bool holding 42: %d\n", as_bool);   /* 1, not 42 */

    bool from_pointer = (void *)0;   /* NULL -> false */
    printf("bool from NULL:  %d\n", from_pointer);
    return 0;
}

עדיין אין %b ב-printf עבור ערכים בוליאניים: הדפיסו אותם עם %d, או המירו אותם לטקסט בעצמכם:

#include <stdio.h>
#include <stdbool.h>

const char *yes_no(bool b) {
    return b ? "true" : "false";
}

int main(void) {
    bool connected = true;
    printf("connected: %s\n", yes_no(connected));
    printf("empty:     %s\n", yes_no(false));
    return 0;
}

ב-C23 זה נעשה פשוט עוד יותר: bool, true ו-false הפכו למילות מפתח אמיתיות, כך שה-include כבר לא נדרש. רוב הקוד היום עדיין מכוון ל-C17, אז השאירו את #include <stdbool.h>.

החזרת ערך בוליאני מפונקציה

כאן bool מצדיק את מקומו בצורה הברורה ביותר:

#include <stdio.h>
#include <stdbool.h>

bool is_even(int n) {
    return n % 2 == 0;
}

bool is_in_range(int value, int low, int high) {
    return value >= low && value <= high;
}

int main(void) {
    printf("is_even(10)            = %d\n", is_even(10));
    printf("is_even(7)             = %d\n", is_even(7));
    printf("is_in_range(5, 1, 10)  = %d\n", is_in_range(5, 1, 10));
    printf("is_in_range(50, 1, 10) = %d\n", is_in_range(50, 1, 10));

    if (is_even(10) && is_in_range(10, 1, 20)) {
        printf("10 is an even number in range.\n");
    }
    return 0;
}

טיפוס החזרה bool אומר למי שקורא לפונקציה מה משמעות הערך. טיפוס החזרה int מפונקציה בשם check_file יכול להיות ערך בוליאני, ספירה או קוד שגיאה, ולפי המוסכמות של ספריות C הוא הרבה פעמים האפשרות השלישית, שבה 0 פירושו הצלחה. ציון הטיפוס מבטל את הניחוש.

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

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

#include <stdio.h>

int main(void) {
    int x = 10;

    if (x = 5) {                     /* assignment, not comparison */
        printf("Branch taken. x is now %d\n", x);
    }

    printf("x = %d (the original 10 is gone)\n", x);
    return 0;
}

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

גרוע מזה, הגרסה עם 0 לעולם לא מריצה את הענף שלה:

if (found = 0) { /* never taken - and found is now 0 */ }

שלוש הגנות, לפי סדר התועלת:

קמפלו עם אזהרות. -Wall תופס את זה:

warning: suggest parentheses around assignment used as truth value

להגיע לאפס אזהרות הוא התיקון האמיתי כאן, והוא עולה דגל אחד.

כתבו את הקבוע ראשון. "תנאי יודה" הופך את שגיאת ההקלדה לשגיאת קומפילציה:

if (5 == x)   /* correct */
if (5 = x)    /* error: not an lvalue - the compiler stops you */

יש צוותים שאוהבים את זה ויש כאלה שמוצאים את זה לא קריא; שתי העמדות סבירות, אבל זה עובד.

היו מכוונים כשזה מה שאתם מתכוונים. השמה בתוך תנאי שימושית באמת לקריאת קלט:

int c;
while ((c = getchar()) != EOF) { ... }

הסוגריים הנוספים סביב c = getchar() נדרשים בגלל סדר הקדימויות, והם גם מאותתים שההשמה מכוונת. זה הניב: אם ההשמה בתוך התנאי שלכם לא נראית ככה, כנראה מדובר בשגיאת הקלדה.

טעויות נפוצות עם ערכים בוליאניים

השוואה ל-true. if (flag == true) עובד עם stdbool.h, אבל נשבר ברגע ש-flag הוא int שמחזיק 42, כי 42 == 1 הוא שקר. כתבו if (flag).

השוואות משורשרות. if (0 < x < 10) תמיד אמת: 0 < x מחזיר 0 או 1, ושניהם קטנים מ-10. כתבו if (x > 0 && x < 10).

אופרטור ביטים במקום אופרטור לוגי. & ו-| אינם && ו-||. הם לא מקצרים את החישוב, והם משלבים ביטים:

#include <stdio.h>

int main(void) {
    int a = 1, b = 2;

    printf("a && b = %d\n", a && b);   /* 1 - both are non-zero */
    printf("a &  b = %d\n", a & b);    /* 0 - 01 AND 10 has no bits in common */
    return 0;
}

שני האופרנדים "אמת", ובכל זאת a & b הוא 0. שימוש ב-& במקום שבו התכוונתם ל-&& יוצר תנאי ששגוי רק עבור ערכים מסוימים, וזה הסוג הקשה ביותר של באג למצוא.

השוואת מספרים עשרוניים לשוויון. if (0.1 + 0.2 == 0.3) הוא שקר. השוו מול סבולת במקום זאת; ראו טיפוסי נתונים כדי להבין למה.