Boolean di C: stdbool.h, _Bool, dan Nilai Kebenaran

Selama 27 tahun pertamanya, C tidak punya tipe boolean. Itu bukan kelalaian, melainkan keputusan desain yang akibatnya langsung kamu temui di hari pertama, beserta satu bug terkenal yang muncul langsung darinya.

Nol Berarti False, Selain Itu True

Aturan kondisi di C tidak mengenal nilai true/false khusus. if, while, for, &&, ||, dan ! semuanya mengajukan satu pertanyaan saja: apakah nilai ini nol?

#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;
}

Bilangan negatif bernilai true. Pecahan bernilai true. Pointer yang tidak null bernilai true. Hanya nol, dalam tipe apa pun, yang bernilai false.

Karena itulah kode C penuh dengan pola yang terlihat singkat sekali sampai kamu tahu aturannya:

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 */

Yang terakhir itu sering menjebak. strcmp mengembalikan 0 kalau kedua string sama, jadi "sama" terbaca sebagai "tidak" di dalam if. Menulis if (strcmp(a, b) == 0) lebih jelas dan hasilnya persis sama.

Perbandingan Menghasilkan int

Perbandingan di C bukan jenis ekspresi khusus. Hasilnya adalah int biasa dengan nilai 1 atau 0, dan kamu bisa mencetaknya, menyimpannya, atau memakainya dalam aritmetika:

#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;
}

Operator ! bekerja dengan cara yang sama: hasilnya 1 kalau operandnya nol dan 0 kalau tidak. Jadi !!x adalah pola klasik untuk mengubah nilai apa pun menjadi tepat 0 atau 1.

bool, true, dan false (C99)

C99 menambahkan tipe boolean sungguhan bernama _Bool, plus sebuah header yang memberinya nama yang mudah dibaca:

#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> sangat kecil: ia mendefinisikan bool sebagai _Bool, true sebagai 1, dan false sebagai 0. Hanya itu isi header-nya. Tetapi memakainya membuat maksudmu terlihat jelas, sesuatu yang tidak pernah bisa dilakukan int flag = 1;.

_Bool punya satu perilaku yang benar-benar berbeda: ia hanya menyimpan 0 atau 1. Meng-assign nilai bukan nol apa pun akan dikonversi menjadi tepat 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;
}

printf tetap tidak punya %b untuk boolean. Cetak dengan %d, atau ubah sendiri menjadi teks:

#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;
}

Di C23 semuanya jadi lebih sederhana lagi: bool, true, dan false menjadi kata kunci sungguhan, jadi include itu tidak lagi diperlukan. Sebagian besar kode saat ini masih menargetkan C17, jadi tetap tulis #include <stdbool.h>.

Mengembalikan Boolean dari Fungsi

Di sinilah bool paling jelas menunjukkan gunanya:

#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;
}

Tipe kembalian bool memberi tahu pemanggil apa arti nilainya. Tipe kembalian int dari fungsi bernama check_file bisa berupa boolean, jumlah, atau kode error, dan menurut konvensi library C sering kali yang ketiga, di mana 0 berarti sukses. Menyebutkan tipenya menghilangkan tebak-tebakan itu.

Bug = vs ==

Karena assignment adalah ekspresi yang menghasilkan nilai yang di-assign, dan karena nilai bukan nol apa pun bernilai true, kode ini bisa dikompilasi:

#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;
}

Dua hal salah sekaligus. Kondisinya meng-assign 5 ke x sehingga nilai lamanya hilang, lalu menguji 5, yang bukan nol, sehingga cabangnya dijalankan. Secara default program ini tidak memunculkan error maupun peringatan.

Lebih buruk lagi, versi dengan 0 tidak pernah menjalankan cabangnya:

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

Ada tiga cara bertahan, diurutkan dari yang paling berguna:

Kompilasi dengan peringatan. -Wall menangkapnya:

warning: suggest parentheses around assignment used as truth value

Membuat peringatan menjadi nol adalah perbaikan yang sebenarnya, dan biayanya hanya satu flag.

Tulis konstantanya lebih dulu. "Kondisi Yoda" membuat salah ketik itu menjadi error kompilasi:

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

Sebagian tim menyukainya dan sebagian lagi menganggapnya sulit dibaca. Kedua pendapat itu masuk akal, tetapi cara ini memang berhasil.

Sengaja dan jelas saat kamu memang bermaksud begitu. Assignment di dalam kondisi benar-benar berguna untuk membaca input:

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

Tanda kurung ekstra di sekitar c = getchar() wajib karena urutan prioritas operator, dan sekaligus menandakan bahwa assignment itu disengaja. Itulah polanya: kalau assignment di dalam kondisimu tidak terlihat seperti itu, kemungkinan besar itu salah ketik.

Kesalahan Umum dengan Boolean

Membandingkan dengan true. if (flag == true) berfungsi dengan stdbool.h, tetapi langsung rusak begitu flag adalah int yang berisi 42, karena 42 == 1 bernilai false. Tulis if (flag).

Perbandingan berantai. if (0 < x < 10) selalu bernilai true: 0 < x menghasilkan 0 atau 1, dan keduanya lebih kecil dari 10. Tulis if (x > 0 && x < 10).

Operator bitwise, bukan logika. & dan | bukan && dan ||. Keduanya tidak melakukan short-circuit, dan keduanya menggabungkan bit:

#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;
}

Kedua operand bernilai "true", tetapi a & b adalah 0. Memakai & padahal maksudmu && menghasilkan kondisi yang hanya salah untuk nilai tertentu, jenis bug yang paling sulit ditemukan.

Membandingkan float dengan tanda sama dengan. if (0.1 + 0.2 == 0.3) bernilai false. Bandingkan dengan toleransi; lihat tipe data untuk alasannya.