C'de Booleanlar: stdbool.h, _Bool ve Doğruluk

C, ilk 27 yılını boolean türü olmadan geçirdi. Bu bir gözden kaçırma değil - sonuçlarıyla daha ilk gün tanıştığınız bir tasarım kararı ve doğrudan ondan doğan meşhur bir hata.

Sıfır Yanlıştır, Geri Kalan Her Şey Doğrudur

C'nin koşul kurallarında özel bir doğru/yanlış değeri yoktur. if, while, for, &&, || ve ! hepsi tam olarak tek bir soru sorar: bu değer sıfır mı?

#include <stdio.h>

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

    if (0)    printf("bu asla yazdirilmaz\n");
    if (0.0)  printf("bu da\n");

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

Negatif sayılar doğrudur. Kesirler doğrudur. Boş olmayan bir gösterici doğrudur. Yalnızca sıfır - hangi türde olursa olsun - yanlıştır.

C kodunun, kuralı bilene kadar aşırı kısa görünen deyimlerle dolu olmasının sebebi budur:

if (count)            /* count sıfır değilse */
if (!count)           /* count sıfırsa */
if (p)                /* p NULL değilse */
if (!strcmp(a, b))    /* metinler eşitse - strcmp eşleşmede 0 döndürür */

Sonuncusu insanları yakalar. strcmp, metinler eşleştiğinde 0 döndürür, dolayısıyla "eşit" bir if içinde "değil" diye okunur. if (strcmp(a, b) == 0) yazmak daha anlaşılırdır ve tam olarak aynı şeyi yapar.

Karşılaştırmalar int Üretir

C'de bir karşılaştırma özel bir tür ifade değildir. Değeri 1 ya da 0 olan sıradan bir int'e değerlenir; onu yazdırabilir, saklayabilir ya da onunla aritmetik yapabilirsiniz:

#include <stdio.h>

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

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

    /* Bir karsilastirmanin 1 ya da 0 olmasindan yararlanarak saymak: */
    int scores[] = {45, 78, 92, 60, 88};
    int passed = 0;
    for (int i = 0; i < 5; i++) {
        passed += (scores[i] >= 60);   /* dogruysa 1, yanlissa 0 ekler */
    }
    printf("5 kisiden %d tanesi gecti\n", passed);
    return 0;
}

! operatörü de aynı şekilde çalışır: işleneni sıfırsa 1, değilse 0 üretir. Dolayısıyla !!x, herhangi bir değeri tam olarak 0 ya da 1'e normalleştiren klasik bir deyimdir.

bool, true ve false (C99)

C99, _Bool adında gerçek bir boolean türü ve ona okunaklı bir isim veren bir başlık ekledi:

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

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

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

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

<stdbool.h> küçücüktür: bool'u _Bool, true'yu 1, false'u 0 olarak tanımlar. Başlığın tamamı budur. Ama onu kullanmak niyeti, int flag = 1;'in asla yapamayacağı biçimde görünür kılar.

_Bool'un gerçekten farklı tek bir davranışı vardır: yalnızca 0 ya da 1 saklar. Sıfırdan farklı herhangi bir değer atamak tam olarak 1'e dönüşür:

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

int main(void) {
    int    as_int  = 42;
    bool   as_bool = 42;      /* 1'e donusturuldu */

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

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

printf içinde booleanlar için hâlâ bir %b yoktur - onları %d ile yazdırın ya da kendiniz metne dönüştürün:

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

const char *yes_no(bool b) {
    return b ? "dogru" : "yanlis";
}

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

C23'te bu daha da basitleşti: bool, true ve false gerçek anahtar kelimeler oldu, dolayısıyla include artık gerekli değil. Bugünkü kodun çoğu hâlâ C17'yi hedefliyor, o yüzden #include <stdbool.h>'yi tutun.

Bir Fonksiyondan Boolean Döndürmek

bool'un yerini en açık biçimde hak ettiği yer burasıdır:

#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, aralikta olan bir cift sayidir.\n");
    }
    return 0;
}

bool dönüş tipi, çağırana değerin ne anlama geldiğini söyler. check_file adlı bir fonksiyondan gelen int dönüş tipi bir boolean, bir sayı ya da bir hata kodu olabilir - ve C kütüphane geleneklerinde çoğu zaman üçüncüsüdür, orada 0 başarı demektir. Türü adlandırmak tahmini ortadan kaldırır.

= ile == Hatası

Atama, atanan değeri üreten bir ifade olduğu ve sıfırdan farklı her değer doğru olduğu için bu derlenir:

#include <stdio.h>

int main(void) {
    int x = 10;

    if (x = 5) {                     /* karsilastirma degil, atama */
        printf("Dal calisti. x artik %d\n", x);
    }

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

Aynı anda iki şey ters gitti. Koşul x'e 5 atayarak değerini yok etti ve sonra sıfırdan farklı olan 5'i test etti, dolayısıyla dal çalıştı. Programda varsayılan olarak ne hata ne de uyarı var.

Daha kötüsü, 0 içeren sürüm dalını hiç çalıştırmaz:

if (found = 0) { /* asla çalışmaz - ve found artık 0 */ }

Yararlılık sırasıyla üç savunma:

Uyarılarla derleyin. -Wall bunu yakalar:

warning: suggest parentheses around assignment used as truth value

Sıfır uyarıya ulaşmak buradaki asıl çözümdür ve bedeli tek bir bayraktır.

Sabiti başa yazın. "Yoda koşulu" yazım hatasını bir derleme hatasına dönüştürür:

if (5 == x)   /* doğru */
if (5 = x)    /* hata: lvalue değil - derleyici sizi durdurur */

Bazı ekipler buna bayılır, bazıları okunmaz bulur; her iki tutum da savunulabilir, ama işe yaradığı kesin.

Kastediyorsanız bilinçli olun. Koşul içinde atama, girdi okumak için gerçekten yararlıdır:

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

c = getchar() çevresindeki fazladan parantezler öncelik için gereklidir ve aynı zamanda atamanın kasıtlı olduğunu işaret eder. Deyim budur - koşul içindeki atamanız buna benzemiyorsa, muhtemelen bir yazım hatasıdır.

Sık Yapılan Boolean Hataları

true ile karşılaştırmak. if (flag == true), stdbool.h ile çalışır, ama flag 42 tutan bir int olduğu anda bozulur, çünkü 42 == 1 yanlıştır. if (flag) yazın.

Zincirleme karşılaştırmalar. if (0 < x < 10) her zaman doğrudur: 0 < x ifadesi 0 ya da 1 üretir ve ikisi de 10'dan küçüktür. if (x > 0 && x < 10) yazın.

Mantıksal yerine bit düzeyi operatörler. & ve |, && ve || değildir. Kısa devre yapmazlar ve bitleri birleştirirler:

#include <stdio.h>

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

    printf("a && b = %d\n", a && b);   /* 1 - ikisi de sifirdan farkli */
    printf("a &  b = %d\n", a & b);    /* 0 - 01 VE 10 ortak bit tasimaz */
    return 0;
}

Her iki işlenen de "doğru", yine de a & b sonucu 0. && kastedip & kullanmak, yalnızca belirli değerler için yanlış olan bir koşul üretir ki bu, bulunması en zor hata türüdür.

Kayan noktalı sayıları eşitlik için karşılaştırmak. if (0.1 + 0.2 == 0.3) yanlıştır. Bunun yerine bir tolerans ile karşılaştırın - nedeni için bkz. veri tipleri.