Typ bool w C: stdbool.h, _Bool i prawdziwość wartości

Przez pierwsze 27 lat C nie miało typu logicznego. To nie przeoczenie, tylko decyzja projektowa z konsekwencjami, na które trafiasz pierwszego dnia, oraz jeden słynny błąd, który z niej bezpośrednio wynika.

Zero to fałsz, wszystko inne to prawda

W regułach warunków w C nie ma specjalnej wartości prawda/fałsz. if, while, for, &&, || i ! zadają dokładnie jedno pytanie: czy ta wartość jest zerem?

#include <stdio.h>

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

    if (0)    printf("to sie nigdy nie wypisze\n");
    if (0.0)  printf("ani to\n");

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

Liczby ujemne są prawdziwe. Ułamki są prawdziwe. Niepusty wskaźnik jest prawdziwy. Fałszywe jest tylko zero, w dowolnym typie.

Dlatego kod w C jest pełen idiomów, które wyglądają zwięźle, dopóki nie znasz tej reguły:

if (count)            /* jeśli count nie jest zerem */
if (!count)           /* jeśli count jest zerem */
if (p)                /* jeśli p nie jest NULL */
if (!strcmp(a, b))    /* jeśli stringi są równe: strcmp zwraca 0 przy zgodności */

Ten ostatni łapie wiele osób. strcmp zwraca 0, gdy stringi są równe, więc w if "równe" czyta się jak "nie". Zapis if (strcmp(a, b) == 0) jest czytelniejszy i robi dokładnie to samo.

Porównania zwracają int

Porównanie w C nie jest specjalnym rodzajem wyrażenia. Daje zwykły int o wartości 1 albo 0, który możesz wypisać, zapisać albo użyć w obliczeniach:

#include <stdio.h>

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

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

    /* Liczenie z wykorzystaniem tego, że porównanie daje 1 albo 0: */
    int scores[] = {45, 78, 92, 60, 88};
    int passed = 0;
    for (int i = 0; i < 5; i++) {
        passed += (scores[i] >= 60);   /* dodaje 1 dla prawdy, 0 dla fałszu */
    }
    printf("zaliczylo %d z 5\n", passed);
    return 0;
}

Operator ! działa tak samo: zwraca 1, jeśli jego argument jest zerem, a 0 w przeciwnym razie. Dlatego !!x to klasyczny idiom, który sprowadza dowolną wartość do dokładnie 0 albo 1.

bool, true i false (C99)

C99 dodało prawdziwy typ logiczny o nazwie _Bool oraz nagłówek, który nadaje mu czytelną nazwę:

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

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

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

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

<stdbool.h> jest malutki: definiuje bool jako _Bool, true jako 1 i false jako 0. To cały nagłówek. Ale jego użycie pokazuje intencję w sposób, w jaki int flag = 1; nigdy tego nie zrobi.

_Bool ma jedno naprawdę odrębne zachowanie: przechowuje tylko 0 albo 1. Przypisanie dowolnej niezerowej wartości zamienia ją na dokładnie 1:

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

int main(void) {
    int    as_int  = 42;
    bool   as_bool = 42;      /* zamienione na 1 */

    printf("int  z 42: %d\n", as_int);
    printf("bool z 42: %d\n", as_bool);   /* 1, a nie 42 */

    bool from_pointer = (void *)0;   /* NULL -> fałsz */
    printf("bool z NULL: %d\n", from_pointer);
    return 0;
}

W printf nadal nie ma %b dla wartości logicznych: wypisuj je przez %d albo samodzielnie zamieniaj je na tekst:

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

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

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

W C23 jest jeszcze prościej: bool, true i false stały się prawdziwymi słowami kluczowymi, więc dołączanie nagłówka nie jest już potrzebne. Większość dzisiejszego kodu wciąż celuje w C17, więc zostaw #include <stdbool.h>.

Zwracanie wartości logicznej z funkcji

Tu bool najwyraźniej zasługuje na swoje miejsce:

#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 to liczba parzysta w zakresie.\n");
    }
    return 0;
}

Typ zwracany bool mówi wywołującemu, co oznacza wartość. Typ int zwracany przez funkcję o nazwie check_file może być wartością logiczną, licznikiem albo kodem błędu, a w konwencjach biblioteki C często jest tym trzecim, gdzie 0 oznacza sukces. Nazwanie typu usuwa zgadywanie.

Błąd = zamiast ==

Ponieważ przypisanie jest wyrażeniem, które zwraca przypisaną wartość, a każda wartość niezerowa jest prawdą, to się kompiluje:

#include <stdio.h>

int main(void) {
    int x = 10;

    if (x = 5) {                     /* przypisanie, nie porównanie */
        printf("Galaz wykonana. x ma teraz wartosc %d\n", x);
    }

    printf("x = %d (pierwotne 10 przepadlo)\n", x);
    return 0;
}

Dwie rzeczy poszły źle jednocześnie. Warunek przypisał 5 do x, niszcząc jego wartość, a potem sprawdził 5, które jest niezerowe, więc gałąź się wykonała. Domyślnie program nie ma ani błędu, ani ostrzeżenia.

Co gorsza, wersja z 0 nigdy nie wykonuje swojej gałęzi:

if (found = 0) { /* nigdy nie wykonana, a found ma teraz wartość 0 */ }

Trzy sposoby obrony, w kolejności przydatności:

Kompiluj z ostrzeżeniami. -Wall to wyłapie:

warning: suggest parentheses around assignment used as truth value

Dojście do zera ostrzeżeń to tutaj prawdziwe rozwiązanie, a kosztuje jedną flagę.

Pisz stałą jako pierwszą. "Warunek Yody" zamienia literówkę w błąd kompilacji:

if (5 == x)   /* poprawnie */
if (5 = x)    /* błąd: to nie lvalue, kompilator cię zatrzyma */

Niektóre zespoły to uwielbiają, a inne uważają za nieczytelne; obie postawy da się obronić, ale to działa.

Rób to świadomie, gdy naprawdę tego chcesz. Przypisanie w warunku jest naprawdę przydatne przy czytaniu wejścia:

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

Dodatkowe nawiasy wokół c = getchar() są wymagane ze względu na priorytet operatorów, a przy okazji sygnalizują, że przypisanie jest zamierzone. To jest ten idiom: jeśli twoje przypisanie w warunku tak nie wygląda, to prawdopodobnie literówka.

Częste błędy z wartościami logicznymi

Porównywanie z true. if (flag == true) działa ze stdbool.h, ale psuje się w chwili, gdy flag jest int o wartości 42, bo 42 == 1 jest fałszem. Pisz if (flag).

Łańcuchowe porównania. if (0 < x < 10) jest zawsze prawdziwe: 0 < x daje 0 albo 1, a oba są mniejsze od 10. Pisz if (x > 0 && x < 10).

Operatory bitowe zamiast logicznych. & i | to nie && i ||. Nie działają na zasadzie krótkiego spięcia i łączą bity:

#include <stdio.h>

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

    printf("a && b = %d\n", a && b);   /* 1: oba są niezerowe */
    printf("a &  b = %d\n", a & b);    /* 0: 01 AND 10 nie mają wspólnych bitów */
    return 0;
}

Oba argumenty są "prawdziwe", a mimo to a & b wynosi 0. Użycie & tam, gdzie chodziło o &&, daje warunek, który jest błędny tylko dla niektórych wartości, a to najtrudniejszy do znalezienia rodzaj błędu.

Porównywanie liczb zmiennoprzecinkowych na równość. if (0.1 + 0.2 == 0.3) jest fałszem. Zamiast tego porównuj z tolerancją; dlaczego, wyjaśnia artykuł o typach danych.