Operator Logika

Operator logika memungkinkan kita menggabungkan beberapa kondisi menjadi satu keputusan. Tanpa operator logika, sebuah program C hanya bisa memutuskan satu pertanyaan pada satu waktu—misalnya “apakah umur pengguna cukup?"—tanpa bisa mempertimbangkan beberapa syarat sekaligus. Pada Chapter ini kita akan membedah tiga operator logika di C: && (AND), || (OR), dan ! (NOT). Kita juga akan menelaah sifat short-circuit evaluation yang tidak hanya soal efisiensi, tetapi juga sering dipakai sebagai mekanisme pengaman agar operasi berbahaya seperti pembagian dengan nol atau akses pointer NULL tidak terjadi.

Tiga Operator Logika #

Sama seperti operator relasional, operator logika di C menghasilkan nilai int 0 (salah) atau 1 (benar). Operand operator logika sendiri boleh berupa ekspresi apa pun yang bernilai non-zero (dianggap benar) atau 0 (dianggap salah).

#include <stdio.h>

int main(void) {
    int umur = 25;
    int punya_sim = 1;

    printf("umur >= 17           : %d\n", umur >= 17);
    printf("punya_sim            : %d\n", punya_sim);
    printf("(umur>=17) && punya_sim : %d\n", (umur >= 17) && punya_sim);
    printf("(umur>=17) || punya_sim : %d\n", (umur >= 17) || punya_sim);
    printf("!(punya_sim)         : %d\n", !punya_sim);
    return 0;
}

Output yang Dihasilkan:

umur >= 17           : 1
punya_sim            : 1
(umur>=17) && punya_sim : 1
(umur>=17) || punya_sim : 1
!(punya_sim)         : 0

Mari kita telaah baris-baris kode di atas:

1. Baris 8 (printf("(umur>=17) && punya_sim : %d\n", ...)): operator && menggabungkan dua kondisi; hasilnya 1 hanya jika keduanya 1. Di sini (25 >= 17) benar (1) dan punya_sim bernilai 1, sehingga hasilnya 1.
2. Baris 9 (printf("(umur>=17) || punya_sim : %d\n", ...)): operator || cukup salah satu operand bernilai benar; karena keduanya sudah benar, hasil tetap 1.
3. Baris 10 (printf("!(punya_sim) : %d\n", !punya_sim);): operator unary ! membalik nilai kebenaran; !1 menjadi 0 dan !0 menjadi 1.

Short-Circuit Evaluation #

Operator && dan || di C mengevaluasi operand dari kiri ke kanan, dan akan berhenti lebih awal begitu hasil akhir dapat dipastikan. Untuk &&, jika operand kiri sudah salah (0), operand kanan tidak dievaluasi sama sekali—hasil pasti 0. Untuk ||, jika operand kiri sudah benar (non-zero), operand kanan tidak dievaluasi—hasil pasti 1. Sifat ini disebut short-circuit evaluation dan dijamin oleh ISO/IEC 9899 §6.5.13 dan §6.5.14.

#include <stdio.h>

int hitung_pangkat(int basis, int eksponen) {
    printf("  -> memanggil hitung_pangkat(%d, %d)\n", basis, eksponen);
    int hasil = 1;
    for (int i = 0; i < eksponen; i++) {
        hasil *= basis;
    }
    return hasil;
}

int main(void) {
    int x = 0;
    int y = 10;

    /* Short-circuit && : jika x == 0, hitung_pangkat TIDAK dipanggil */
    int aman = (x != 0) && (hitung_pangkat(y, 3) < 1000);
    printf("aman (x=0) : %d\n\n", aman);

    /* Short-circuit || : jika x != 0, sisi kanan TIDAK dievaluasi */
    x = 5;
    aman = (x != 0) || (hitung_pangkat(y, 3) < 1000);
    printf("aman (x=5) : %d\n", aman);
    return 0;
}

Output yang Dihasilkan:

  -> memanggil hitung_pangkat(10, 3)
aman (x=0) : 0

aman (x=5) : 1

Perhatikan bahwa fungsi hitung_pangkat hanya dipanggil sekali—pada kasus pertama. Pada kasus kedua, karena x != 0 sudah benar, operator || memutuskan hasil pasti 1 tanpa perlu mengevaluasi sisi kanan, sehingga pesan "memanggil hitung_pangkat" tidak muncul untuk kasus tersebut.

Menggabungkan Banyak Kondisi #

Untuk keputusan yang melibatkan banyak syarat, kita dapat merangkai operator logika dalam satu ekspresi. Mulai C99, header <stdbool.h> menyediakan tipe bool dengan konstanta true dan false yang sebenarnya hanya alias untuk 1 dan 0. Penggunaan bool membuat kode lebih ekspresif tanpa mengubah perilaku runtime.

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

int main(void) {
    int nilai = 78;
    int absensi = 90;
    int tugas = 85;

    bool lulus_nilai = (nilai >= 70);
    bool lulus_absensi = (absensi >= 75);
    bool lulus_tugas = (tugas >= 75);

    bool lulus = lulus_nilai && lulus_absensi && lulus_tugas;
    bool perlu_remidi = !lulus;

    printf("Nilai    : %d  -> lulus_nilai    = %d\n", nilai, lulus_nilai);
    printf("Absensi  : %d  -> lulus_absensi  = %d\n", absensi, lulus_absensi);
    printf("Tugas    : %d  -> lulus_tugas    = %d\n", tugas, lulus_tugas);
    printf("Lulus akhir?        : %d\n", lulus);
    printf("Perlu remidi?       : %d\n", perlu_remidi);
    return 0;
}

Output yang Dihasilkan:

Nilai    : 78  -> lulus_nilai    = 1
Absensi  : 90  -> lulus_absensi  = 1
Tugas    : 85  -> lulus_tugas    = 1
Lulus akhir?        : 1
Perlu remidi?       : 0

Ekspresi lulus_nilai && lulus_absensi && lulus_tugas mengevaluasi dari kiri ke kanan dengan short-circuit. Jika lulus_nilai bernilai 0, dua kondisi sisanya tidak dievaluasi. Hal ini berguna ketika kondisi di sebelah kanan membutuhkan biaya komputasi yang mahal atau bergantung pada keberhasilan kondisi sebelumnya.

Operator logika akan kita pakai berulang-ulang pada Section control flow untuk membangun keputusan bersyarat. Sebelumnya, kita akan meninjau operator assignment yang menyimpan hasil ekspresi kembali ke variabel.