C'de Operatörler: Aritmetik, Mantıksal ve Öncelik

Operatörler C'nin fiilleridir: değer alır ve yenilerini üretirler. Yaklaşık 40 tane vardır, ama bir düzinesi kodun çoğunu kapsar ve bunlardan ikisinin kendi bölümlerini hak edecek kadar keskin tuzakları vardır.

Aritmetik Operatörler

#include <stdio.h>

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

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3  - tam sayi bolmesi! */
    printf("a %% b  = %d\n", a % b);  /* 2  - kalan */
    printf("-a     = %d\n", -a);      /* tekli eksi */
    return 0;
}

(Biçim metnindeki %% gerçek bir yüzde işareti yazdırır - tek başına % bir biçim belirteci başlatırdı.)

Beş ikili aritmetik operatör + - * / %'dir, artı olumsuzlama için tekli - ve esasen hiçbir şey yapmayan +.

Tam Sayı Bölmesi Tuzağı

İki tam sayıyla a / b, tam sayı bölmesi yapar ve kalanı atar. Yuvarlama yoktur - sonuç sıfıra doğru kırpılır.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* bolme ONCE, int olarak yapilir */
    printf("yanlis ortalama = %f\n", wrong);   /* 3.000000 */
    return 0;
}

O son durum ürüne kadar giden hatadır. Bir double'a atamak yardımcı olmaz: total / count bölmesi atama gerçekleşmeden önce çoktan tamamlanmış ve çoktan bir int olmuştur. Çözüm, ifadenin içinde bir işleneni kayan noktalı yapmaktır; genellikle bir dönüşümle.

İki ilgili kural: tam sayılarla sıfıra bölmek tanımsız davranıştır ve tipik olarak programı çökertir; ayrıca INT_MIN / -1 taşar.

Mod Operatörü

% kalanı verir ve yalnızca tam sayılarda çalışır:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d cifttir\n", i);
        } else {
            printf("%d tektir\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d saniye = %ds %ddk %dsn\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

Çiftlik için x % 2 == 0 testi ve bir indeksi bir dizi etrafında sarmak için % n kullanmak, iki günlük kullanımdır.

Negatif sayılarla C'nin %'si bölünenin işaretini izler:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, 2 degil */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

Dolayısıyla x negatif olabildiğinde x % 2 == 1 teklik için bozuk bir testtir - -7 % 2 sonucu -1'dir. Bunun yerine x % 2 != 0 kullanın.

Kayan noktalı kalanlar için % bir derleme hatasıdır; math.h'deki fmod()'u kullanın.

Atama ve Bileşik Atama

= bir değer saklar. Bileşik biçimler bir işlemi saklamayla birleştirir:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5, x = x + 5 demektir, ama x'i yalnızca bir kez değerlendirir - hedef arr[compute_index()] gibi bir şey olduğunda bu önemlidir.

Atamanın kendisi, atanan değeri üreten bir ifadedir; a = b = c = 0'ın çalışmasının (sağdan sola atar) ve = ile == hatasının sessizce derlenmesinin sebebi budur.

Artırma ve Azaltma

++ bir ekler, -- bir çıkarır. Her biri ön ek ve son ek biçiminde gelir:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a 5 alir (eski deger), sonra i 6 olur */
    printf("son ek: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* once j 6 olur, sonra b 6 alir */
    printf("on ek:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* tek basina bir deyim olarak ++k ile ozdes */
    printf("deyim: k = %d\n", k);
    return 0;
}

Tek başına bir deyim olarak ikisi birbirinin yerine geçer ve for başlığındaki alışıldık seçim olan i++, gelenekten başka derin bir sebebi olmadan öyledir.

Yapmamanız gereken şey, aynı zamanda değiştirildiği bir ifadede bir değişkeni birden fazla kez kullanmaktır:

int i = 5;
int x = i++ + i++;      /* tanımsız davranış */
arr[i] = i++;           /* tanımsız davranış */
printf("%d %d", i++, i);/* tanımsız davranış */

C, o alt ifadelerin değerlendirilme sırasını tanımlamaz, dolayısıyla sonuç yalnızca belirtilmemiş değildir - tüm programın davranışı tanımsızdır. Deyimi ikiye bölün, belirsizlik yok olur.

Karşılaştırma Operatörleri

Altı tanedir ve hepsi bir int üretir: doğru için 1, yanlış için 0.

#include <stdio.h>

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

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

Sonucun ayrılmış bir boolean türü yerine düz bir int olması C'nin tanımlayıcı bir özelliğidir - = ile == hatası dahil bundan çıkanlar için bkz. C'de booleanlar.

İki karşılaştırma hatası C'ye özgüdür. Zincirleme, matematiğin düşündürdüğü gibi çalışmaz: if (1 < x < 10) her zaman doğrudur, çünkü 1 < x 0 ya da 1'e değerlenir ve sonra bu 10 ile karşılaştırılır. if (x > 1 && x < 10) yazın. Ve metinleri == ile karşılaştırmak metni değil göstericileri karşılaştırır - string.h'deki strcmp'yi kullanın.

Mantıksal Operatörler

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("Arac kullanabilir\n");
    }

    if (age < 13 || age > 65) {
        printf("Indirimli bilet\n");
    } else {
        printf("Tam fiyat\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& VE'dir, || VEYA'dır, ! DEĞİL'dir. Üçü de sıfırdan farklı her değeri doğru sayar.

Kısa devre yaparlar: && bir işlenen yanlış olur olmaz durur ve || biri doğru olur olmaz durur. Gerisi asla değerlendirilmez ve bu yalnızca bir iyileştirme değildir - güvenlik için güvenebileceğiniz bir garantidir:

#include <stdio.h>

int is_safe(int *p) {
    /* p NULL ise *p asla degerlendirilmez - && once durur. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("gercek gostericiyle: %d\n", is_safe(&value));
    printf("NULL ile:            %d\n", is_safe(NULL));
    return 0;
}

O iki testin sırasını değiştirin, NULL çağrısı boş bir göstericiyi dereferans eder ve çöker. Önce koruyun, sonra kullanın - bir && zincirindeki sıra mantığın bir parçasıdır.

Koşul Operatörü

C'nin tek üç işlenenli operatörü iki değer arasından seçer:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

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

    printf("%d oge%s\n", a, (a == 1) ? "" : "ler");
    return 0;
}

kosul ? dogruysa_deger : yanlissa_deger. Bir ifadedir, dolayısıyla bir if deyiminin sığamayacağı yerlere sığar - bir printf argümanının içine, bir ilk değere. Kısa tutun; iç içe koşullar hızla okunmaz hâle gelir.

Kısaca Bit Düzeyi Operatörler

Bunlar bir tam sayının tek tek bitleri üzerinde çalışır:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* ikilik tabanda 1100 */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, VE */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, VEYA */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, XOR */
    printf("~a     = %u\n", ~a);       /* DEGIL - her biti ters cevirir */
    printf("a << 2 = %u\n", a << 2);   /* 48 - yukari kaydirir, 4 ile carpar */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - asagi kaydirir, 4'e boler */
    return 0;
}

Bayraklar, maskeler ve donanım yazmaçları için kullanılırlar. İki uyarı: & ve |, && ve || değildir (kısa devre yapmazlar ve bit bit çalışırlar) ve işaretli bir değeri kaydırmak ya da tipin genişliğinden fazla kaydırmak tanımsızdır. Bit işleri için işaretsiz tipler kullanın.

Öncelik

Bir ifadede parantez olmadığında neyin neye bağlanacağına bu tablo karar verir. En yüksek öncelik önce:

Pratik sonuçlar:

a + b * c       /* a + (b * c) demektir */
a < b == c < d  /* (a < b) == (c < d) demektir - nadiren kastedilen şey */
x & 1 == 0      /* x & (1 == 0), yani x & 0 demektir - klasik bir hata */
*p++            /* *(p++) demektir - p'yi dereferans et, sonra ilerlet */

O üçüncü satır ezberlenmeye değer: ==, &'den daha sıkı bağlanır, dolayısıyla bit maskesi testleri parantez ister - (x & 1) == 0.

Kimse on beş seviyenin hepsini hatırlamaz ve kimsenin hatırlamasına gerek yok. *'ın +'yı yendiğini, karşılaştırmaların &&'i, onun da ||'yi yendiğini ve geri kalan her şeyin parantez aldığını öğrenin:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

O satırda gereksiz parantezler var ve onlarla daha iyi.