Operator di C: aritmetika, logika, dan prioritas operator

Operator adalah kata kerjanya C: operator menerima nilai dan menghasilkan nilai baru. Jumlahnya sekitar 40, tapi selusin saja sudah mencakup kebanyakan kode, dan dua di antaranya punya jebakan yang cukup tajam sampai layak dibahas di bagian tersendiri.

Operator aritmetika

#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  - integer division! */
    printf("a %% b  = %d\n", a % b);  /* 2  - the remainder */
    printf("-a     = %d\n", -a);      /* unary minus */
    return 0;
}

(%% di format string mencetak tanda persen apa adanya: % saja akan memulai format specifier.)

Lima operator aritmetika biner adalah + - * / %, ditambah - unary untuk negasi dan + yang pada dasarnya tidak melakukan apa-apa.

Jebakan pembagian integer

a / b dengan dua integer melakukan pembagian integer dan membuang sisanya. Tidak ada pembulatan: hasilnya dipotong ke arah nol.

#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;      /* division happens FIRST, as ints */
    printf("wrong average = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Kasus terakhir itulah bug yang lolos sampai ke production. Menyimpan hasilnya ke double tidak membantu: pembagian total / count sudah selesai, dan sudah berupa int, sebelum penugasan terjadi. Perbaikannya adalah menjadikan salah satu operand floating point di dalam ekspresinya, biasanya dengan cast.

Ada dua aturan terkait: membagi integer dengan nol adalah undefined behavior dan biasanya membuat program crash, dan INT_MIN / -1 menyebabkan overflow.

Operator modulus

% menghasilkan sisa bagi dan hanya bekerja untuk integer:

#include <stdio.h>

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

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

Menguji x % 2 == 0 untuk bilangan genap dan memakai % n untuk memutar indeks kembali ke awal array adalah dua pemakaian sehari-harinya.

Dengan angka negatif, % di C mengikuti tanda bilangan yang dibagi:

#include <stdio.h>

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

Jadi x % 2 == 1 adalah uji bilangan ganjil yang rusak kalau x bisa negatif: -7 % 2 hasilnya -1. Pakai x % 2 != 0 sebagai gantinya.

Untuk sisa bagi floating point, % adalah error kompilasi; pakai fmod() dari math.h.

Penugasan dan penugasan gabungan

= menyimpan sebuah nilai. Bentuk gabungannya menyatukan sebuah operasi dengan penyimpanan:

#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 berarti x = x + 5, tapi x hanya dievaluasi sekali, dan itu penting saat targetnya sesuatu seperti arr[compute_index()].

Penugasan sendiri adalah ekspresi yang menghasilkan nilai yang diberikan. Karena itulah a = b = c = 0 bekerja (penugasannya dari kanan ke kiri), dan karena itu juga kesalahan = versus == bisa dikompilasi tanpa peringatan.

Increment dan decrement

++ menambah satu, -- mengurangi satu. Masing-masing punya bentuk prefix dan postfix:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a gets 5 (the old value), then i becomes 6 */
    printf("postfix: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j becomes 6 first, then b gets 6 */
    printf("prefix:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* as a statement on its own, identical to ++k */
    printf("statement: k = %d\n", k);
    return 0;
}

Sebagai pernyataan yang berdiri sendiri, keduanya bisa saling menggantikan, dan i++ jadi pilihan yang lazim di header for hanya karena tradisi.

Yang tidak boleh kamu lakukan adalah memakai sebuah variabel lebih dari sekali dalam ekspresi yang juga mengubahnya:

int i = 5;
int x = i++ + i++;      /* undefined behavior */
arr[i] = i++;           /* undefined behavior */
printf("%d %d", i++, i);/* undefined behavior */

C tidak mendefinisikan urutan evaluasi subekspresi-subekspresi itu, jadi hasilnya bukan sekadar tidak ditentukan: perilaku seluruh program menjadi undefined. Pecah pernyataannya menjadi dua dan ambiguitasnya hilang.

Operator perbandingan

Ada enam, dan semuanya menghasilkan int: 1 untuk benar dan 0 untuk salah.

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

Hasil yang berupa int biasa, bukan tipe boolean khusus, adalah ciri khas C. Lihat halaman boolean di C untuk akibatnya, termasuk bug = versus ==.

Ada dua kesalahan perbandingan yang khas C. Perbandingan berantai tidak bekerja seperti di matematika: if (1 < x < 10) selalu benar, karena 1 < x dievaluasi menjadi 0 atau 1, lalu hasil itu dibandingkan dengan 10. Tulis if (x > 1 && x < 10). Lalu membandingkan string dengan == membandingkan pointer, bukan teks: pakai strcmp dari string.h.

Operator logika

#include <stdio.h>

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

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

    if (age < 13 || age > 65) {
        printf("Discounted ticket\n");
    } else {
        printf("Full price\n");
    }

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

&& adalah AND, || adalah OR, ! adalah NOT. Ketiganya menganggap nilai apa pun yang bukan nol sebagai benar.

Operator ini melakukan short-circuit: && berhenti begitu satu operand bernilai salah, dan || berhenti begitu satu operand bernilai benar. Sisanya tidak pernah dievaluasi. Ini bukan sekadar optimasi, tapi jaminan yang bisa kamu andalkan demi keamanan:

#include <stdio.h>

int is_safe(int *p) {
    /* If p is NULL, *p is never evaluated - the && stops first. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("with a real pointer: %d\n", is_safe(&value));
    printf("with NULL:           %d\n", is_safe(NULL));
    return 0;
}

Tukar urutan kedua uji itu, dan pemanggilan dengan NULL akan melakukan dereference null pointer lalu crash. Jaga dulu, baru pakai: urutan di rantai && adalah bagian dari logikanya.

Operator kondisional

Satu-satunya operator tiga operand di C memilih di antara dua nilai:

#include <stdio.h>

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

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

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

condition ? value_if_true : value_if_false. Ini ekspresi, jadi bisa ditaruh di tempat pernyataan if tidak bisa: di dalam argumen printf, atau di inisialisasi. Buat tetap singkat; operator kondisional bersarang cepat sekali jadi sulit dibaca.

Operator bitwise, sekilas

Operator ini bekerja pada bit-bit individual sebuah integer:

#include <stdio.h>

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

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, AND */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, OR  */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, XOR */
    printf("~a     = %u\n", ~a);       /* NOT - flips every bit */
    printf("a << 2 = %u\n", a << 2);   /* 48 - shift up, multiplies by 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - shift down, divides by 4 */
    return 0;
}

Operator ini dipakai untuk flag, mask, dan register hardware. Ada dua peringatan: & dan | bukan && dan || (keduanya tidak melakukan short-circuit dan bekerja bit demi bit), dan menggeser nilai bertanda (signed) atau menggeser lebih jauh dari lebar tipenya adalah undefined. Pakai tipe unsigned untuk pekerjaan bit.

Prioritas operator

Saat sebuah ekspresi tidak punya tanda kurung, tabel inilah yang menentukan apa terikat ke apa. Prioritas tertinggi lebih dulu:

Konsekuensi praktisnya:

a + b * c       /* means a + (b * c) */
a < b == c < d  /* means (a < b) == (c < d) - rarely what you meant */
x & 1 == 0      /* means x & (1 == 0), i.e. x & 0 - a classic bug */
*p++            /* means *(p++) - dereference p, then advance it */

Baris ketiga itu layak dihafal: == terikat lebih kuat daripada &, jadi uji bitmask butuh tanda kurung: (x & 1) == 0.

Tidak ada yang ingat kelima belas tingkat itu, dan memang tidak perlu. Pelajari bahwa * mengalahkan +, bahwa perbandingan mengalahkan && yang mengalahkan ||, dan bahwa sisanya diberi tanda kurung:

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

Baris itu punya tanda kurung yang berlebihan, dan justru jadi lebih baik karenanya.