Bahasa C memiliki banyak operator yang bisa kita gunakan untuk berbagai keperluan. Salah satunya adalah kelompok bitwise operator. Sayangnya, programmer awam masih belum banyak tahu kegunaannya, sehingga pendayagunaannya pun masih terbatas.
Jadi, sekarang tulisan ini akan menunjukkan beberapa trik terkait dengan penggunaan operator tersebut di C.
Yang pertama adalah operator shift left dan shift right. Operator ini digunakan untuk menggeser bit ke arah kiri atau kanan.
// 1 00000001
// 1<<1 00000010
// 1 00000001
// 1<<3 00001000
// 8 00001000
// 8<<1 00010000
// 8 00001000
// 8>>1 00000100
// 8 00001000
// 8>>4 00000000
// 8 00001000
// 8<<5 00000000
Kelompok operator ini ternyata dapat digunakan untuk melakukan perkalian dan pembagian cepat dengan nilai pembagi berkelipatan pangkat dua (1, 2, 4, 8, 16, 32, 64, ...). Dokumentasi intel menunjukkan bahwa instruksi perkalian dan pembagian membutuhkan CPU clock lebih besar dari instruksi aritmatika dan logika lainnya.
http://www.penguin.cz/~literakl/intel/s.html#SHL
http://www.penguin.cz/~literakl/intel/m.html#MUL
Jika kita mengembangkan program yang fokus pada performa, gunakanlah kedua operator ini jika bertemu perkalian atau pembagian degan bilangan berkelipatan pangkat 2.
10 x 2^0 = 10 x 1 = 10 << 0
10 x 2^1 = 10 x 2 = 10 << 1
10 x 2^2 = 10 x 4 = 10 << 2
10 x 2^3 = 10 x 8 = 10 << 3
10 x 2^4 = 10 x 16 = 10 << 4
dst...
10 / 2^0 = 10 / 1 = 10 >> 0
10 / 2^1 = 10 / 2 = 10 >> 1
10 / 2^2 = 10 / 4 = 10 >> 2
10 / 2^3 = 10 / 8 = 10 >> 3
10 / 2^4 = 10 / 16 = 10 >> 4
Untuk menghemat disk dan memori space, seringkali status di representasikan dalam bentuk BOOLEAN (hanya memiliki 2 kemungkinan: benarr/salah) berukuran 1 bit. Keadaan benar/true diwakili oleh 1 dan salah diwakili nilai 0. Dalam setiap byte data terdapat banyak bit yang dapat digunakan untuk menyimpan state/keadaan tertentu. Untuk menangani nilai boolean itu tadi, kita harus menggunakan banyak operator logika.
Sebagai contoh, saat ingin memeriksa kodisi nilai bit-3 (dihitung mulai 0 dr kanan) pada sebuah data byte; maka perlu dilakukan operasi semcam berikut ini.
// Diketahui:
// 15 00001111
// 8 00001000
// 1 00000001
// 1<<3 00001000
//Contoh...
// 8 & (1<<3)
// 00001000
// 00001000
// hasilnya..
// 00001000
//Contoh lain...
// 15 & (1<<3)
// 00001111
// 00001000
// hasilnya..
// 00001000
// Dalam pemrograman, semua nilai BUKAN 0 memiliki arti TRUE
Sehingga, untuk memeriksa state bit dalam suatu data byte, kita bisa melakukan cara seperti ini. Jika return value BUKAN 0, artinya true atau benar bahwa bit yang ditentukan oleh argumen posisi bernilai 1.
int cek_state(char state, char posisi){
return state & (1 << posisi);
}
Kemudian, ketika hendak meng-set bit (dari 0 ke 1), operator bitwise | (OR) adalah yang harus berperan. Misal, kita akan set bit-3(urutan ke empat dr kanan)
// Diketahui:
// 0 00000000
// 1 00000001
// 1<<3 00001000
// Contoh...
// 0 | (1<<3)
// 00000000
// 00001000
// di OR hasilnya..
// 00001000
// Contoh lain...
// 15 | (1<<3)
// 00001111
// 00001000
// di OR hasilnya..
// 00001111
Kodenya dalam C bisa ditulis seperti berikut:
char set_state(char state, char posisi){
return state | (1 << posisi);
}
Berbeda lagi ketika hendak meng-unset state (dari 1 ke 0). Maka, perlu satu lagi bitwise operator pembantu, yaitu negate ( ~ ).
// Diketahui:
// 0 00000000
// 8 00001000
// 1 00000001
// 1<<3 00001000
// ~(1<<3) 11110111
// Contoh...
// 8 & ~(1<<3)
// 00001000
// 11110111
// di AND hasilnya..
// 00000000
// Contoh lain...
// 15 & (1<<3)
// 00001111
// 11110111
// di AND hasilnya..
// 00000111
Sehingga kode untuk unset bit harus seperti ini:
char unset_state(char state, char posisi){
return state & ~(1 << posisi);
}
Masih bingung ya? Jangan kawatir, ambil sebuah pensil dan gambarkan bagaimana deretan biner dikepala anda. Coba berikan perlakuan bitwise pada bit tersebut dan gambar hasilnya. Jika tetap masih bingung, buka buku matematika SMA anda. :)
0 comments