Operator & Expression

Pada pertemuan sebelumnya, kita telah mengenal variabel, tipe data, serta cara menerima dan menampilkan data menggunakan bahasa C.

Sekarang kita akan mulai melakukan sesuatu terhadap data tersebut.

Misalnya kita memiliki dua buah variabel:

int a = 10;
int b = 5;

Kita tentu dapat melakukan berbagai proses terhadap nilai a dan b, seperti menjumlahkannya, membandingkan nilainya, atau melakukan operasi langsung terhadap representasi bit-nya.

Untuk melakukan hal tersebut, bahasa C menyediakan berbagai jenis operator yang dapat kita gunakan di dalam sebuah expression.

Pada materi ini kita akan mempelajari bagaimana operator bekerja, bagaimana sebuah expression menghasilkan nilai, serta bagaimana komputer menentukan urutan operasi ketika terdapat beberapa operator sekaligus.

Review Binary Number

Sebelum masuk ke pembahasan operator, mari kita mengingat kembali sedikit mengenai sistem bilangan biner.

Komputer bekerja dengan menggunakan sistem bilangan biner (binary number system), yaitu sistem bilangan berbasis 2 atau base-2.

Berbeda dengan sistem desimal yang menggunakan sepuluh digit dari 0 sampai 9, sistem biner hanya menggunakan dua digit:

0 dan 1

Setiap digit dalam sebuah bilangan biner disebut sebagai bit (binary digit).

Sebagai contoh:

Decimal : 5
Binary  : 0101

Decimal : 10
Binary  : 1010

Nilai setiap posisi pada bilangan biner merupakan perpangkatan dari angka 2, dimulai dari posisi paling kanan.

Sebagai contoh, perhatikan bilangan berikut:

Jika kita tuliskan nilai setiap posisinya:

Posisi Bit :   3    2    1    0
Nilai      :  2³   2²   2¹   2⁰
Binary     :   1    1    0    1

Sehingga:

\begin{aligned} 1101_2 &= (1 \times 2^3) + (1 \times 2^2) + (0 \times 2^1) + (1 \times 2^0) \\ &= 8 + 4 + 0 + 1 \\ &= 13_{10} \end{aligned}

Artinya, bilangan biner 1101 memiliki nilai yang sama dengan bilangan desimal 13.

MSB dan LSB

Ketika membaca sebuah bilangan biner, terdapat dua posisi bit yang memiliki istilah khusus, yaitu Most Significant Bit (MSB) dan Least Significant Bit (LSB).

Perhatikan bilangan biner berikut:

1 1 0 1
↑     ↑
MSB   LSB

Most Significant Bit (MSB)

Most Significant Bit (MSB) adalah bit yang berada pada posisi paling kiri dari sebuah bilangan biner.

MSB berada pada posisi dengan nilai tempat paling besar.

Pada bilangan:

bit paling kiri adalah:

Karena berada pada posisi $2^3$ , nilai posisi tersebut adalah:

1 \times 2^3 = 8

Sehingga pada bilangan 1101:

MSB = 1
Nilai posisi MSB = 8

Pada bilangan bertanda (signed number), MSB juga dapat digunakan sebagai bagian dari representasi tanda bilangan.

Dalam representasi two's complement, bit 0 pada posisi MSB menunjukkan bilangan positif, sedangkan bit 1 menunjukkan bilangan negatif.

Least Significant Bit (LSB)

Least Significant Bit (LSB) adalah bit yang berada pada posisi paling kanan dari sebuah bilangan biner.

LSB merupakan bit dengan nilai tempat paling kecil, yaitu:

2^0 = 1

Pada bilangan:

bit paling kanan adalah:

Sehingga:

LSB = 1
Nilai posisi LSB = 1

LSB juga dapat digunakan untuk mengetahui apakah sebuah bilangan bulat merupakan bilangan genap atau ganjil.

Perhatikan beberapa contoh berikut:

Decimal   Binary   LSB
       0100      0
       0101      1
      1010      0
      1101      1

Dari contoh tersebut kita dapat melihat pola:

LSB = 0  → Bilangan Genap
LSB = 1  → Bilangan Ganjil

Hal ini terjadi karena LSB merepresentasikan nilai $2^0$ , yaitu 1.

Jika bit tersebut bernilai 0, maka bilangan tidak memiliki tambahan nilai 1 sehingga nilainya genap.

Sedangkan jika bit tersebut bernilai 1, bilangan memiliki tambahan nilai 1 sehingga nilainya menjadi ganjil.

Contoh

Misalkan kita memiliki bilangan biner:

Kita dapat menentukan MSB dan LSB-nya sebagai berikut:

1 0 1 1 0
↑       ↑
MSB     LSB

Sehingga:

MSB = 1
LSB = 0

Karena LSB bernilai 0, kita juga dapat mengetahui bahwa nilai desimal dari bilangan tersebut merupakan bilangan genap.

Selanjutnya kita akan mulai menggunakan nilai dan variabel tersebut dalam berbagai operasi menggunakan Operator dan Expression.

Operator dan Expression

Setelah memahami kembali bagaimana sebuah nilai direpresentasikan, sekarang kita akan mulai melakukan berbagai operasi terhadap nilai tersebut.

Dalam bahasa C, operator adalah simbol yang digunakan untuk melakukan suatu operasi terhadap sebuah nilai atau variabel.

Sebagai contoh:

int a = 10;
int b = 5;

int hasil = a + b;

Pada baris:

a + b

terdapat tiga bagian utama:

a   → Operand
+   → Operator
b   → Operand

Operand adalah nilai atau variabel yang digunakan dalam sebuah operasi, sedangkan operator adalah simbol yang menentukan operasi apa yang akan dilakukan terhadap operand tersebut.

Gabungan antara operand dan operator yang menghasilkan sebuah nilai disebut sebagai expression.

Sehingga:

a + b

merupakan sebuah expression yang menghasilkan nilai 15 apabila a = 10 dan b = 5.

Perhatikan contoh berikut:

int hasil = a + b;

Kita dapat membacanya sebagai:

a + b          → Expression
a dan b        → Operand
+              → Operator
hasil          → Variabel tempat menyimpan hasil
=              → Assignment Operator

Pada bahasa C terdapat beberapa jenis operator yang akan kita pelajari:

Jenis Operator	Fungsi
Arithmetic	Melakukan operasi matematika
Assignment	Memberikan atau memperbarui nilai variabel
Relational	Membandingkan dua nilai
Logical	Menggabungkan atau memproses kondisi logika
Bitwise	Melakukan operasi langsung pada bit

Kita akan mempelajari masing-masing operator tersebut secara bertahap.

Arithmetic Operator

Arithmetic Operator merupakan operator yang digunakan untuk melakukan operasi matematika terhadap suatu nilai.

Misalnya kita memiliki dua variabel:

int a = 10;
int b = 5;

Kita dapat menjumlahkan kedua nilai tersebut menggunakan operator +:

int hasil = a + b;

Nilai yang tersimpan pada variabel hasil adalah:

Bahasa C menyediakan beberapa operator aritmatika:

Operator	Nama	Kegunaan
`+`	Addition	Penjumlahan
`-`	Subtraction	Pengurangan
`*`	Multiplication	Perkalian
`/`	Division	Pembagian
`%`	Modulus	Mendapatkan sisa hasil pembagian
`++`	Increment	Menambah nilai sebesar 1
`--`	Decrement	Mengurangi nilai sebesar 1

Operator tersebut dapat digunakan baik secara langsung terhadap nilai maupun terhadap nilai yang tersimpan di dalam sebuah variabel.

Operasi Aritmatika Dasar

Empat operasi aritmatika yang paling umum digunakan adalah penjumlahan, pengurangan, perkalian, dan pembagian.

Operator yang digunakan adalah:

+   Penjumlahan
-   Pengurangan
*   Perkalian
/   Pembagian

Perhatikan contoh program berikut:

#include <stdio.h>

int main() {
    int a = 12;
    int b = 4;

    printf("Penjumlahan : %d\n", a + b);
    printf("Pengurangan : %d\n", a - b);
    printf("Perkalian   : %d\n", a * b);
    printf("Pembagian   : %d\n", a / b);

    return 0;
}

Output di terminal:

Penjumlahan : 16
Pengurangan : 8
Perkalian   : 48
Pembagian   : 3

Mari kita lihat expression yang terdapat pada program tersebut.

Pada expression:

a + b

komputer mengambil nilai dari variabel a dan b:

a = 12
b = 4

kemudian melakukan operasi:

12 + 4

sehingga menghasilkan:

Hal yang sama terjadi pada operator lainnya:

- 4 = 8
* 4 = 48
/ 4 = 3

Hasil dari sebuah operasi aritmatika juga dapat disimpan ke dalam variabel.

Contoh:

#include <stdio.h>

int main() {
    int panjang = 8;
    int lebar = 5;

    int luas = panjang * lebar;

    printf("Luas = %d\n", luas);

    return 0;
}

Output di terminal:

Luas = 40

Pada kode:

int luas = panjang * lebar;

bagian:

panjang * lebar

merupakan sebuah expression.

Expression tersebut dievaluasi terlebih dahulu sehingga menghasilkan nilai 40, kemudian nilai tersebut disimpan ke dalam variabel luas.

Modulus

Selain operasi matematika dasar, bahasa C juga memiliki operator modulus yang ditulis menggunakan simbol:

Operator modulus digunakan untuk mendapatkan sisa dari suatu pembagian.

Sebagai contoh:

10 / 3 = 3 dengan sisa 1

Maka:

10 % 3 = 1

Contoh lainnya:

% 4 = 0
% 4 = 3
% 5 = 2

Perhatikan contoh program berikut:

#include <stdio.h>

int main() {
    int angka = 17;
    int pembagi = 5;

    int sisa = angka % pembagi;

    printf("Sisa pembagian = %d\n", sisa);

    return 0;
}

Output di terminal:

Sisa pembagian = 2

Pada expression:

angka % pembagi

nilai yang dihitung adalah:

17 % 5

Karena:

17 = (5 × 3) + 2

maka sisa pembagiannya adalah:

Operator modulus juga dapat digunakan untuk mengetahui apakah sebuah bilangan merupakan bilangan genap atau ganjil.

Sebuah bilangan genap akan habis dibagi 2, sehingga:

angka % 2 = 0

Sedangkan bilangan ganjil akan memiliki sisa pembagian 1:

angka % 2 = 1

Sebagai contoh:

8 % 2 = 0
9 % 2 = 1

Hal ini memiliki hubungan dengan pembahasan LSB sebelumnya.

Bilangan genap memiliki LSB 0, sedangkan bilangan ganjil memiliki LSB 1.

Increment dan Decrement

Dalam pemrograman, kita sering kali perlu menambah atau mengurangi nilai sebuah variabel sebesar 1.

Misalnya:

int angka = 5;

angka = angka + 1;

Setelah baris tersebut dijalankan, nilai angka menjadi:

Bahasa C menyediakan operator khusus untuk melakukan operasi tersebut, yaitu increment dan decrement.

++   Increment
--   Decrement

Increment (++) digunakan untuk menambah nilai sebuah variabel sebesar 1.

Sedangkan decrement (--) digunakan untuk mengurangi nilai sebuah variabel sebesar 1.

Contoh:

#include <stdio.h>

int main() {
    int angka = 5;

    angka++;
    printf("Setelah increment : %d\n", angka);

    angka--;
    printf("Setelah decrement : %d\n", angka);

    return 0;
}

Output di terminal:

Setelah increment : 6
Setelah decrement : 5

Pada kode:

angka++;

nilai angka bertambah sebesar 1.

Sehingga secara sederhana dapat dianggap seperti:

angka = angka + 1;

Sedangkan:

angka--;

dapat dianggap seperti:

angka = angka - 1;

Namun operator increment dan decrement memiliki dua cara penulisan, yaitu pre dan post.

Pre-Increment dan Post-Increment

Increment dapat ditulis dengan dua cara:

++angka;

dan:

angka++;

Keduanya sama-sama menambah nilai angka sebesar 1, tetapi terdapat perbedaan ketika operator tersebut digunakan di dalam sebuah expression.

Post-Increment

Post-increment ditulis dengan meletakkan operator ++ setelah nama variabel:

angka++;

Pada post-increment, nilai variabel yang sekarang akan digunakan terlebih dahulu di dalam expression.

Setelah itu, nilainya baru ditambah sebesar 1.

Perhatikan contoh berikut:

#include <stdio.h>

int main() {
    int angka = 5;
    int hasil;

    hasil = angka++;

    printf("Hasil = %d\n", hasil);
    printf("Angka = %d\n", angka);

    return 0;
}

Output di terminal:

Hasil = 5
Angka = 6

Pada baris:

hasil = angka++;

nilai angka yang saat itu masih bernilai 5 terlebih dahulu digunakan dan dimasukkan ke variabel hasil.

Setelah itu nilai angka baru ditambah sebesar 1.

Urutannya dapat kita bayangkan seperti berikut:

Nilai awal angka = 5

1. hasil menerima nilai angka
   hasil = 5

2. angka bertambah 1
   angka = 6

Sehingga pada akhirnya:

hasil = 5
angka = 6

Pre-Increment

Pre-increment ditulis dengan meletakkan operator ++ sebelum nama variabel:

++angka;

Berbeda dengan post-increment, pada pre-increment nilai variabel ditambah sebesar 1 terlebih dahulu.

Setelah itu, nilai barunya digunakan di dalam expression.

Perhatikan contoh berikut:

#include <stdio.h>

int main() {
    int angka = 5;
    int hasil;

    hasil = ++angka;

    printf("Hasil = %d\n", hasil);
    printf("Angka = %d\n", angka);

    return 0;
}

Output di terminal:

Hasil = 6
Angka = 6

Pada baris:

hasil = ++angka;

nilai angka yang awalnya 5 terlebih dahulu ditambah sebesar 1.

Urutannya:

Nilai awal angka = 5

1. angka bertambah 1
   angka = 6

2. hasil menerima nilai angka
   hasil = 6

Sehingga:

hasil = 6
angka = 6

Perbandingan Pre dan Post Increment

Perhatikan perbandingan berikut:

Expression	Nilai awal `angka`	Nilai `hasil`	Nilai akhir `angka`
`hasil = angka++;`	`5`	`5`	`6`
`hasil = ++angka;`	`5`	`6`	`6`

Perbedaan utamanya terdapat pada kapan nilai variabel digunakan di dalam expression.

angka++   → gunakan nilainya terlebih dahulu,
            kemudian tambahkan 1

++angka   → tambahkan 1 terlebih dahulu,
            kemudian gunakan nilainya

Konsep yang sama juga berlaku pada operator decrement:

angka--;

dan:

--angka;

Keduanya mengurangi nilai sebesar 1, tetapi urutan perubahan nilai terhadap expression mengikuti konsep post dan pre yang sama.

tip

Jika operator ++ atau -- digunakan sendiri dalam satu baris, seperti:

angka++;

atau:

++angka;

keduanya sama-sama menghasilkan perubahan nilai sebesar 1.

Perbedaannya menjadi penting ketika operator tersebut digunakan sebagai bagian dari sebuah expression.

Assignment Operator

Assignment Operator adalah operator yang digunakan untuk memberikan atau menyimpan sebuah nilai ke dalam variabel.

Operator assignment yang paling dasar adalah:

Sebagai contoh:

int angka = 10;

Pada kode tersebut, nilai 10 diberikan kepada variabel angka menggunakan operator =.

Operator assignment juga dapat digunakan untuk memperbarui nilai variabel yang sebelumnya sudah memiliki nilai.

Contoh:

int angka = 10;

angka = 20;

Setelah baris:

angka = 20;

dijalankan, nilai lama pada variabel angka akan digantikan dengan nilai baru.

Sehingga:

Nilai awal  : 10
Nilai akhir : 20

Selain operator =, bahasa C juga menyediakan compound assignment operator.

Operator ini merupakan bentuk singkat dari operasi yang melibatkan sebuah variabel dengan nilainya sendiri.

Operator	Contoh	Sama dengan
`=`	`x = 5`	`x = 5`
`+=`	`x += 3`	`x = x + 3`
`-=`	`x -= 3`	`x = x - 3`
`*=`	`x *= 3`	`x = x * 3`
`/=`	`x /= 3`	`x = x / 3`
`%=`	`x %= 3`	`x = x % 3`
`&=`	`x &= 3`	`x = x & 3`
`	=`	`x
`^=`	`x ^= 3`	`x = x ^ 3`
`>>=`	`x >>= 3`	`x = x >> 3`
`<<=`	`x <<= 3`	`x = x << 3`

Untuk saat ini, mari kita fokus terlebih dahulu pada assignment yang berhubungan dengan operasi aritmatika.

Perhatikan contoh berikut:

#include <stdio.h>

int main() {
    int nilai = 10;

    nilai += 5;
    printf("Setelah += 5 : %d\n", nilai);

    nilai -= 3;
    printf("Setelah -= 3 : %d\n", nilai);

    nilai *= 2;
    printf("Setelah *= 2 : %d\n", nilai);

    nilai /= 4;
    printf("Setelah /= 4 : %d\n", nilai);

    return 0;
}

Output di terminal:

Setelah += 5 : 15
Setelah -= 3 : 12
Setelah *= 2 : 24
Setelah /= 4 : 6

Mari kita lihat prosesnya satu per satu.

Nilai awal:

nilai = 10

Kemudian:

nilai += 5;

memiliki arti yang sama dengan:

nilai = nilai + 5;

Sehingga:

nilai = 10 + 5
nilai = 15

Kemudian:

nilai -= 3;

sama dengan:

nilai = nilai - 3;

Sehingga:

nilai = 15 - 3
nilai = 12

Dengan cara yang sama:

nilai *= 2
nilai = 12 * 2
nilai = 24

dan:

nilai /= 4
nilai = 24 / 4
nilai = 6

Compound assignment membuat penulisan kode menjadi lebih singkat ketika kita ingin memperbarui nilai suatu variabel menggunakan nilai variabel itu sendiri.

Relational Operator

Relational Operator atau Comparison Operator digunakan untuk membandingkan dua buah nilai atau variabel.

Hasil dari sebuah perbandingan dalam bahasa C akan menghasilkan:

1 → True
0 → False

Sebagai contoh:

10 > 5

Expression tersebut bernilai benar karena 10 memang lebih besar daripada 5.

Sehingga hasilnya adalah:

Sedangkan:

10 < 5

bernilai salah.

Sehingga hasilnya adalah:

Bahasa C menyediakan beberapa relational operator:

Operator	Nama	Contoh	Keterangan
`==`	Equal to	`x == y`	Bernilai `1` jika kedua nilai sama
`!=`	Not equal	`x != y`	Bernilai `1` jika kedua nilai berbeda
`>`	Greater than	`x > y`	Bernilai `1` jika `x` lebih besar dari `y`
`<`	Less than	`x < y`	Bernilai `1` jika `x` lebih kecil dari `y`
`>=`	Greater than or equal to	`x >= y`	Bernilai `1` jika `x` lebih besar atau sama dengan `y`
`<=`	Less than or equal to	`x <= y`	Bernilai `1` jika `x` lebih kecil atau sama dengan `y`

Perhatikan contoh program berikut:

#include <stdio.h>

int main() {
    int a = 10;
    int b = 5;

    printf("a == b : %d\n", a == b);
    printf("a != b : %d\n", a != b);
    printf("a > b  : %d\n", a > b);
    printf("a < b  : %d\n", a < b);
    printf("a >= b : %d\n", a >= b);
    printf("a <= b : %d\n", a <= b);

    return 0;
}

Output di terminal:

a == b : 0
a != b : 1
a > b  : 1
a < b  : 0
a >= b : 1
a <= b : 0

Karena:

a = 10
b = 5

maka:

== 5 → False → 0
!= 5 → True  → 1
> 5  → True  → 1
< 5  → False → 0
>= 5 → True  → 1
<= 5 → False → 0

Perbedaan `=` dan `==`

Perhatikan kedua operator berikut:

=
==

Meskipun terlihat mirip, keduanya memiliki fungsi yang berbeda.

Operator:

digunakan untuk memberikan nilai kepada sebuah variabel.

Contoh:

int angka = 10;

Sedangkan:

==

digunakan untuk membandingkan apakah dua nilai sama.

Contoh:

angka == 10

Sehingga:

=   → Assignment
==  → Comparison

warning

Jangan tertukar antara operator = dan ==.

= digunakan untuk memberikan nilai, sedangkan == digunakan untuk membandingkan dua nilai.

Logical Operator

Logical Operator digunakan untuk menentukan hubungan logika antara beberapa nilai atau kondisi.

Logical operator biasanya digunakan ketika kita memiliki lebih dari satu kondisi yang ingin diperiksa secara bersamaan.

Bahasa C memiliki tiga logical operator utama:

Operator	Nama	Keterangan
`&&`	AND	Bernilai benar jika kedua kondisi benar
`		`
`!`	NOT	Membalik nilai logika

Seperti relational operator, hasil dari operasi logical juga dapat direpresentasikan sebagai:

1 → True
0 → False

Logical AND (`&&`)

Operator AND ditulis menggunakan:

&&

AND akan menghasilkan nilai benar hanya jika kedua kondisi bernilai benar.

Sebagai contoh:

5 < 10 && 8 > 3

Kita dapat memisahkannya menjadi:

5 < 10 → True
8 > 3  → True

Karena kedua kondisi benar:

True && True → True

Sehingga hasil akhirnya:

Perhatikan tabel sederhana berikut:

Kondisi A	Kondisi B	`A && B`
`0`	`0`	`0`
`0`	`1`	`0`
`1`	`0`	`0`
`1`	`1`	`1`

Logical OR (`||`)

Operator OR ditulis menggunakan:

||

OR akan menghasilkan nilai benar jika setidaknya salah satu kondisi bernilai benar.

Contoh:

5 > 10 || 8 > 3

Jika dipisahkan:

5 > 10 → False
8 > 3  → True

Maka:

False || True → True

Sehingga hasilnya:

Tabel sederhananya:

| Kondisi A | Kondisi B | A || B | | :---: | :---: | :---: | | 0 | 0 | 0 | | 0 | 1 | 1 | | 1 | 0 | 1 | | 1 | 1 | 1 |

Logical NOT (`!`)

Operator NOT ditulis menggunakan:

NOT digunakan untuk membalik nilai logika.

Jika suatu kondisi bernilai benar:

maka setelah diberikan operator NOT:

!1

hasilnya menjadi:

Sebaliknya:

!0

akan menghasilkan:

Tabel sederhananya:

Nilai	`!Nilai`
`0`	`1`
`1`	`0`

Contoh Logical Operator

Perhatikan program berikut:

#include <stdio.h>

int main() {
    int x = 5;

    printf("AND : %d\n", x > 0 && x < 10);
    printf("OR  : %d\n", x < 0 || x == 5);
    printf("NOT : %d\n", !(x == 5));

    return 0;
}

Output di terminal:

AND : 1
OR  : 1
NOT : 0

Mari kita lihat satu per satu.

Expression:

x > 0 && x < 10

dengan:

x = 5

akan menjadi:

5 > 0 && 5 < 10

Kedua kondisi bernilai benar:

True && True

sehingga hasilnya:

Kemudian:

x < 0 || x == 5

menjadi:

5 < 0 || 5 == 5

Kondisi pertama salah, tetapi kondisi kedua benar:

False || True

Karena menggunakan OR, cukup salah satu kondisi bernilai benar untuk menghasilkan:

Terakhir:

!(x == 5)

Expression:

x == 5

bernilai benar:

Kemudian operator NOT membalik nilai tersebut:

!1 → 0

Sehingga hasil akhirnya adalah:

Logical operator memungkinkan kita menggabungkan beberapa hasil perbandingan menjadi sebuah expression yang lebih kompleks.

Konsep ini nantinya akan banyak digunakan ketika kita mulai mempelajari pengambilan keputusan atau conditional statement.

Bitwise Operator

Bitwise Operator adalah operator yang bekerja secara langsung pada representasi bit dari sebuah nilai.

Berbeda dengan logical operator yang digunakan untuk mengolah kondisi, bitwise operator melakukan operasi terhadap setiap bit yang terdapat di dalam sebuah bilangan.

Karena itu, pembahasan mengenai bilangan biner pada bagian sebelumnya akan kembali kita gunakan di sini.

Bahasa C memiliki beberapa bitwise operator:

Operator	Nama	Keterangan
`&`	Bitwise AND	Melakukan operasi AND pada setiap pasangan bit
`	`	Bitwise OR
`^`	Bitwise XOR	Melakukan operasi XOR pada setiap pasangan bit
`~`	Bitwise Complement	Membalik setiap bit
`<<`	Shift Left	Menggeser bit ke kiri
`>>`	Shift Right	Menggeser bit ke kanan

Untuk memahami cara kerjanya, kita akan menggunakan dua nilai berikut:

Decimal  Binary
5        0101
3        0011

Bitwise AND (`&`)

Operator Bitwise AND ditulis menggunakan simbol:

AND membandingkan setiap pasangan bit dari dua buah nilai.

Hasil sebuah bit akan bernilai 1 hanya jika kedua bit yang dibandingkan sama-sama bernilai 1.

Tabel sederhananya:

A	B	`A & B`
`0`	`0`	`0`
`0`	`1`	`0`
`1`	`0`	`0`
`1`	`1`	`1`

Sekarang kita gunakan:

5 = 0101
3 = 0011

Operasi AND dilakukan pada setiap pasangan bit:

    0101
&   0011
---------
    0001

Hasilnya:

0001 = 1

Sehingga:

5 & 3 = 1

Contoh dalam bahasa C:

#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;

    printf("%d\n", a & b);

    return 0;
}

Output di terminal:

Bitwise OR (`|`)

Operator Bitwise OR ditulis menggunakan simbol:

OR menghasilkan bit 1 jika setidaknya salah satu dari dua bit yang dibandingkan bernilai 1.

Tabel sederhananya:

A	B	`A \| B`
`0`	`0`	`0`
`0`	`1`	`1`
`1`	`0`	`1`
`1`	`1`	`1`

Menggunakan nilai yang sama:

5 = 0101
3 = 0011

maka:

    0101
|   0011
---------
    0111

Bilangan biner:

memiliki nilai desimal:

Sehingga:

5 | 3 = 7

Contoh dalam bahasa C:

#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;

    printf("%d\n", a | b);

    return 0;
}

Output di terminal:

Bitwise XOR (`^`)

Operator Bitwise XOR atau Exclusive OR ditulis menggunakan:

XOR menghasilkan 1 jika kedua bit yang dibandingkan memiliki nilai yang berbeda.

Jika kedua bit memiliki nilai yang sama, hasilnya adalah 0.

Tabel sederhananya:

A	B	`A ^ B`
`0`	`0`	`0`
`0`	`1`	`1`
`1`	`0`	`1`
`1`	`1`	`0`

Menggunakan:

5 = 0101
3 = 0011

maka:

    0101
^   0011
---------
    0110

Bilangan:

memiliki nilai desimal:

Sehingga:

5 ^ 3 = 6

Contoh dalam bahasa C:

#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;

    printf("%d\n", a ^ b);

    return 0;
}

Output di terminal:

warning

Jangan menganggap operator ^ sebagai operasi pangkat.

Dalam bahasa C, ^ merupakan operator Bitwise XOR.

Bitwise Complement (`~`)

Operator Bitwise Complement ditulis menggunakan simbol:

Berbeda dengan AND, OR, dan XOR yang menggunakan dua operand, complement hanya menggunakan satu operand.

Operator ini akan membalik setiap bit.

Artinya:

0 → 1
1 → 0

Sebagai contoh, jika kita menggunakan representasi sederhana 4-bit:

Nilai awal : 0101
Setelah ~  : 1010

Setiap bit telah dibalik:

menjadi 1
menjadi 0
menjadi 1
menjadi 0

Shift Left (`<<`)

Operator Shift Left digunakan untuk menggeser seluruh bit ke arah kiri.

Operator ini ditulis menggunakan:

<<

Sebagai contoh:

5 = 0101

Jika bit digeser satu posisi ke kiri:

0101 << 1

maka:

0101
 ↓
1010

Hasilnya:

1010 = 10

Sehingga:

5 << 1 = 10

Contoh dalam bahasa C:

#include <stdio.h>

int main() {
    int angka = 5;

    printf("%d\n", angka << 1);

    return 0;
}

Output di terminal:

Shift Right (`>>`)

Operator Shift Right digunakan untuk menggeser seluruh bit ke arah kanan.

Operator ini ditulis menggunakan:

>>

Sebagai contoh:

10 = 1010

Jika digeser satu posisi ke kanan:

1010 >> 1

maka:

1010
 ↓
0101

Hasilnya:

0101 = 5

Sehingga:

10 >> 1 = 5

Contoh dalam bahasa C:

#include <stdio.h>

int main() {
    int angka = 10;

    printf("%d\n", angka >> 1);

    return 0;
}

Output di terminal:

Contoh Bitwise Operator

Sekarang mari kita gabungkan beberapa operator bitwise dalam satu program.

#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;

    printf("a & b  = %d\n", a & b);
    printf("a | b  = %d\n", a | b);
    printf("a ^ b  = %d\n", a ^ b);
    printf("a << 1 = %d\n", a << 1);
    printf("a >> 1 = %d\n", a >> 1);

    return 0;
}

Output di terminal:

a & b  = 1
a | b  = 7
a ^ b  = 6
a << 1 = 10
a >> 1 = 2

Jika kita melihat nilai a = 5 dalam bentuk biner:

5 = 0101

maka setiap operasi sebenarnya bekerja terhadap bit-bit tersebut, bukan terhadap tampilan angka desimalnya.

Sebagai contoh:

5 & 3

    0101
&   0011
---------
    0001

Result = 1

Sedangkan:

5 | 3

    0101
|   0011
---------
    0111

Result = 7

dan:

5 ^ 3

    0101
^   0011
---------
    0110

Result = 6

Inilah alasan mengapa pemahaman mengenai binary number penting ketika kita bekerja menggunakan bitwise operator.

Expression

Setelah mempelajari berbagai jenis operator, sekarang kita akan membahas bagaimana operator tersebut digunakan bersama-sama dalam sebuah expression.

Expression adalah kombinasi dari variabel, konstanta, operator, dan fungsi yang ketika dievaluasi akan menghasilkan sebuah nilai.

Expression dapat berbentuk sangat sederhana.

Sebagai contoh:

5 + 3

Expression tersebut memiliki dua nilai:

5
3

dan satu operator:

Ketika dievaluasi:

5 + 3 = 8

maka expression tersebut menghasilkan nilai:

Expression juga dapat menggunakan variabel.

Contoh:

int a = 10;
int b = 5;

int hasil = a + b;

Pada bagian:

a + b

terdapat sebuah expression yang menggunakan nilai dari variabel a dan b.

Karena:

a = 10
b = 5

maka:

a + b
↓
10 + 5
↓
15

Nilai 15 kemudian disimpan ke dalam variabel hasil.

Expression juga tidak terbatas pada arithmetic operator.

Sebagai contoh:

a > b

merupakan sebuah expression yang menggunakan relational operator.

Jika:

a = 10
b = 5

maka:

10 > 5

menghasilkan:

karena kondisi tersebut bernilai benar.

Expression dengan Beberapa Operator

Sebuah expression dapat menggunakan lebih dari satu operator.

Contoh:

a + b * 2

Expression tersebut memiliki:

Operand  : a, b, 2
Operator : +, *

Contoh lainnya:

a > b && b > 0

Expression tersebut menggunakan dua jenis operator sekaligus:

>   → Relational Operator
&&  → Logical Operator

Jika:

a = 10
b = 5

maka expression tersebut dapat kita baca sebagai:

10 > 5 && 5 > 0

Masing-masing relational expression menghasilkan:

10 > 5 → 1
5 > 0  → 1

Kemudian:

1 && 1

menghasilkan:

Sehingga keseluruhan expression bernilai benar.

Contoh Expression dalam Program

Perhatikan program berikut:

#include <stdio.h>

int main() {
    int a = 10;
    int b = 5;

    int hasilAritmatika = a + b * 2;
    int hasilPerbandingan = a > b;
    int hasilLogical = a > b && b > 0;

    printf("Aritmatika  : %d\n", hasilAritmatika);
    printf("Perbandingan: %d\n", hasilPerbandingan);
    printf("Logical     : %d\n", hasilLogical);

    return 0;
}

Output di terminal:

Aritmatika  : 20
Perbandingan: 1
Logical     : 1

Pada expression:

a + b * 2

operasi perkalian dilakukan sebelum penjumlahan.

Sehingga:

10 + 5 * 2

dihitung menjadi:

10 + 10

dan menghasilkan:

Mengapa perkalian dikerjakan terlebih dahulu?

Hal tersebut ditentukan oleh aturan yang disebut Operator Precedence, yang akan kita bahas setelah memahami komponen-komponen sebuah expression.

Component of Expression

Sebuah expression terdiri dari beberapa komponen.

Secara umum, dua komponen yang paling penting adalah:

Operand
Operator

Operand

Operand adalah nilai yang digunakan atau diproses oleh sebuah operator.

Operand dapat berupa variabel maupun konstanta.

Sebagai contoh:

a + 5

Pada expression tersebut:

a → Variable
5 → Constant

Keduanya merupakan operand.

Contoh lainnya:

x * y

Pada expression tersebut:

x → Operand berupa Variable
y → Operand berupa Variable

Operator

Operator adalah simbol yang menentukan operasi apa yang dilakukan terhadap operand.

Sebagai contoh:

a + 5

operator yang digunakan adalah:

Sedangkan pada:

a >= b

operator yang digunakan adalah:

>=

Selama materi ini kita telah mengenal beberapa kelompok operator:

Arithmetic Operator
Assignment Operator
Relational Operator
Logical Operator
Bitwise Operator

Mengidentifikasi Component of Expression

Perhatikan expression berikut:

hasil = (a + 5) * b;

Kita dapat mengidentifikasi komponennya sebagai berikut:

Variable   : hasil, a, b
Constant   : 5
Operator   : =, +, *

Expression:

(a + 5) * b

terlebih dahulu menghasilkan sebuah nilai.

Nilai tersebut kemudian disimpan ke variabel:

hasil

menggunakan assignment operator:

Contoh lain:

hasil = (a > b) && (b != 0);

Komponennya:

Variable              : hasil, a, b
Constant              : 0
Relational Operator   : >, !=
Logical Operator      : &&
Assignment Operator   : =

Dengan memahami komponen expression, kita dapat membaca sebuah baris program yang terlihat kompleks menjadi bagian-bagian yang lebih kecil.

Operator Precedence

Sebuah expression dapat memiliki lebih dari satu operator.

Sebagai contoh:

3 + 4 * 2

Pertanyaannya adalah:

Operasi mana yang akan dilakukan terlebih dahulu?

Apakah:

3 + 4

atau:

4 * 2

Urutan tersebut ditentukan oleh Operator Precedence.

Operator Precedence adalah aturan yang menentukan urutan operator yang akan dievaluasi terlebih dahulu dalam sebuah expression.

Urutan Operasi Aritmatika

Untuk operasi aritmatika, kita dapat mengingat aturan yang sudah dikenal dalam matematika, yaitu PEMDAS:

P  → Parentheses
E  → Exponents
MD → Multiplication dan Division
AS → Addition dan Subtraction

Operasi multiplication dan division dilakukan dari kiri ke kanan.

Begitu juga addition dan subtraction dilakukan dari kiri ke kanan.

warning

Dalam bahasa C, simbol ^ bukan operator pangkat.

Simbol ^ merupakan Bitwise XOR, seperti yang telah kita pelajari pada bagian Bitwise Operator.

Pada bagian ini, PEMDAS digunakan untuk membantu memahami konsep urutan operasi aritmatika.

Contoh Operator Precedence

Perhatikan expression berikut:

3 + 4 * 2

Perkalian memiliki prioritas lebih tinggi daripada penjumlahan.

Maka:

3 + 4 * 2

akan dihitung sebagai:

3 + (4 * 2)

Langkah pertama:

4 * 2 = 8

Kemudian:

3 + 8 = 11

Sehingga:

3 + 4 * 2 = 11

Contoh program:

#include <stdio.h>

int main() {
    int hasil = 3 + 4 * 2;

    printf("Hasil = %d\n", hasil);

    return 0;
}

Output di terminal:

Hasil = 11

Menggunakan Parentheses

Kita dapat menggunakan tanda kurung () untuk menentukan operasi mana yang ingin dikerjakan terlebih dahulu.

Bandingkan expression berikut:

3 + 4 * 2

dengan:

(3 + 4) * 2

Expression pertama:

3 + 4 * 2

= 3 + 8
= 11

Sedangkan expression kedua:

(3 + 4) * 2

= 7 * 2
= 14

Perhatikan program berikut:

#include <stdio.h>

int main() {
    int hasil1 = 3 + 4 * 2;
    int hasil2 = (3 + 4) * 2;

    printf("Tanpa parentheses : %d\n", hasil1);
    printf("Dengan parentheses: %d\n", hasil2);

    return 0;
}

Output di terminal:

Tanpa parentheses : 11
Dengan parentheses: 14

Meskipun menggunakan angka dan operator yang sama, kedua expression menghasilkan nilai yang berbeda karena urutan evaluasinya berbeda.

Operasi dengan Tingkat Precedence yang Sama

Jika dua operator memiliki tingkat precedence yang sama, urutan evaluasinya dapat dilakukan dari kiri ke kanan.

Sebagai contoh:

20 / 5 * 2

Division dan multiplication berada pada tingkat yang sama.

Maka expression dibaca dari kiri ke kanan:

20 / 5 * 2

Langkah pertama:

20 / 5 = 4

Kemudian:

4 * 2 = 8

Sehingga:

20 / 5 * 2 = 8

Hal yang sama berlaku pada addition dan subtraction.

Contoh:

10 - 4 + 2

Dievaluasi dari kiri ke kanan:

- 4 = 6

+ 2 = 8

Sehingga:

10 - 4 + 2 = 8

Precedence pada Expression yang Lebih Kompleks

Operator precedence menjadi semakin penting ketika sebuah expression menggunakan beberapa jenis operator.

Perhatikan:

10 > 5 && 3 < 8

Expression tersebut sebenarnya terdiri dari beberapa bagian:

10 > 5
3 < 8

Kedua perbandingan tersebut menghasilkan:

10 > 5 → 1
3 < 8  → 1

Kemudian kedua hasil tersebut diproses oleh logical operator:

1 && 1

Sehingga:

Untuk membuat expression seperti ini lebih mudah dibaca, kita dapat menggunakan parentheses:

(10 > 5) && (3 < 8)

Walaupun parentheses tidak selalu diperlukan pada expression tersebut, penggunaannya dapat membuat maksud program menjadi lebih jelas.

tip

Ketika sebuah expression mulai sulit dibaca, gunakan parentheses () untuk memperjelas urutan operasi yang kalian inginkan.

Sebagai contoh:

(a + b) * c

biasanya lebih mudah dipahami daripada expression panjang yang hanya mengandalkan aturan precedence.

Review Binary Number​

MSB dan LSB​

Most Significant Bit (MSB)​

Least Significant Bit (LSB)​

Contoh​

Operator dan Expression​

Arithmetic Operator​

Operasi Aritmatika Dasar​

Modulus​

Increment dan Decrement​

Pre-Increment dan Post-Increment​

Post-Increment​

Pre-Increment​

Perbandingan Pre dan Post Increment​

Assignment Operator​

Relational Operator​

Perbedaan = dan ==​

Logical Operator​

Logical AND (&&)​

Logical OR (||)​

Logical NOT (!)​

Contoh Logical Operator​

Bitwise Operator​

Bitwise AND (&)​

Bitwise OR (|)​

Bitwise XOR (^)​

Bitwise Complement (~)​

Shift Left (<<)​

Shift Right (>>)​

Contoh Bitwise Operator​

Expression​

Expression dengan Beberapa Operator​

Contoh Expression dalam Program​

Component of Expression​

Operand​

Operator​

Mengidentifikasi Component of Expression​

Operator Precedence​

Urutan Operasi Aritmatika​

Contoh Operator Precedence​

Menggunakan Parentheses​

Operasi dengan Tingkat Precedence yang Sama​

Precedence pada Expression yang Lebih Kompleks​

Review Binary Number

MSB dan LSB

Most Significant Bit (MSB)

Least Significant Bit (LSB)

Contoh

Operator dan Expression

Arithmetic Operator

Operasi Aritmatika Dasar

Modulus

Increment dan Decrement

Pre-Increment dan Post-Increment

Post-Increment

Pre-Increment

Perbandingan Pre dan Post Increment

Assignment Operator

Relational Operator

Perbedaan `=` dan `==`

Logical Operator

Logical AND (`&&`)

Logical OR (`||`)

Logical NOT (`!`)

Contoh Logical Operator

Bitwise Operator

Bitwise AND (`&`)

Bitwise OR (`|`)

Bitwise XOR (`^`)

Bitwise Complement (`~`)

Shift Left (`<<`)

Shift Right (`>>`)

Contoh Bitwise Operator

Expression

Expression dengan Beberapa Operator

Contoh Expression dalam Program

Component of Expression

Operand

Operator

Mengidentifikasi Component of Expression

Operator Precedence

Urutan Operasi Aritmatika

Contoh Operator Precedence

Menggunakan Parentheses

Operasi dengan Tingkat Precedence yang Sama

Precedence pada Expression yang Lebih Kompleks