- Bit level operation:
- A bit with value 1 represents the logical value true
- A bit with value 0 represents
the logical value false
- Operation is performed on
a series of bit by
performing the operation
on one bit
at a time
- Examples:
Bitwise AND: 00010100 (0 AND 0 = 0 0 AND 1 = 0) 00001111 (1 AND 0 = 0 1 AND 1 = 1) -------- 00000100
Bitwise OR: 00010100 (0 OR 0 = 0 0 OR 1 = 1) 00001111 (1 OR 0 = 1 1 OR 1 = 1) -------- 00011111
Bitwise XOR: 00010100 (0 XOR 0 = 0 0 XOR 1 = 1) (exclusive OR) 00001111 (1 XOR 0 = 1 1 XOR 1 = 0) -------- 00011011
Bitwise NOT: 00010100 (NOT 0 = 1 NOT 1 = 0) -------- 11101011
- Bitwise operators:
Operator symbol Meaning & Bitwise AND | Bitwise OR ^ Bitwise XOR ~ Bitwise NOT
- Example program:
int main( int argc, char* argv[] ) { char a = 20; /* 00010100 = 16 + 4 = 20 */ char b = 15; /* 00001111 = 8 + 4 + 2 + 1 = 15 */ printf( "a & b = %d\n", (a & b) ); printf( "a | b = %d\n", (a | b) ); printf( "a ^ b = %d\n", (a ^ b) ); printf( "~ a = %d\n", (~ a) ); }Output: (Note: the "%d" conversion character will output the bit expressions as a decimal number representation)
a & b = 4 ( 4 = 00000100 ) a | b = 31 ( 31 = 00011111 ) a ^ b = 27 ( 27 = 00011011 ) ~ a = -21 ( -21 = 11101011 --- this is 2'c complement code for signed numbers ! )
(I have added the convertion of the decimal number into bits between brackets for your viewing convenience)
- The bit-wise operations
are typically used do the following:
- Set a certain bit in a byte, short, int, or long variable
- Clear a certain bit in a byte, short, int, or long variable
- Flip a certain bit (0 ⇒ 1 or 1 ⇒ 0) in a byte, short, int, or long variable
- Test a certain bit in a byte, short, int, or long variable
- Note:
- The bit-wise operations
often use a certain
bit pattern
(or bit mask)
- The bit pattern can often
be expression more easily
using different number systems
We will also look at how to express a value in different number system in C
- The bit-wise operations
often use a certain
bit pattern
(or bit mask)
- Set a certain bit in a
bit pattern
- Suppose the variable a
contains a bit pattern:
a = 1010...x...1101
- Problem:
- Set the bit x to the value 1 without changing all other bits in the pattern.
- We can set the bit
x inside the
bit pattern to 1 using
the OR operation with
the following
specific pattern:
a = 1010...x...1101 0000..010..0000 OR --------------- 1010...1...1101
- Suppose the variable a
contains a bit pattern:
- Example:
set
the 2nd bit
and the 4th bit in
a bit pattern
int main( int argc, char* argv[] ) { char a = 0; /* 0 = 00000000 */ /* Bit pos: 76543210 */ a = a | 4; /* 16 = 00000100 - set 2nd bit */ a = a | 16; /* 16 = 00010000 - set 4th bit */ printf( "a = %d\n", a ); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc bit-op2.c
- To run: ./a.out
- Fact:
- The decimal number system is terrible for expression a bit pattern
- Solution:
- Use different number systems !!!
- Bit patterns is a
royal pain to write using
decimal representation
It is a lot easier to write bit patterns using the Binary Number System
- C provides you with
different number systems to
write
bit patterns with more ease !
- Denoting binary numbers in
C (with the
prefix 0b):
- A number that starts with the prefix 0b (ZERO b) is considered to use the Binary Number System as representation
Example:
0bxxxxxxxx = the binary number xxxxxxxx Example: 0b00001111 = 15 decimal
- Example:
int main( int argc, char* argv[] ) { char a = 0; /* 0 = 00000000 */ /* Bit pos: 76543210 */ a = a | 0b00000100; /* Now: a = 00000100 */ printf( "a = %d\n", a ); a = a | 0b00010000; /* Now: a = 00010100 */ printf( "a = %d\n", a ); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc bit-op2a.c
- To run: ./a.out
- Disadvantage of
the Binary Number System:
- The number of digits needed will grown very fast !!!
We can use other related number system to express bit patterns in more compact form
- Octal numbers uses
base 8 is the representation
Example:
Representation Value represented --------------------------------------------------- 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 10 8 11 9 12 10 ... ... 23 2*8 + 3 = 19 - The Octal number system (8)
is related
to the Binary number system (2)
because:
8 = 23Because the FONT color="blue">Octal number system (8) is related to the Binary number system (2), converting values between these systems is easy (we have discussed this at the start of this course !!!)
- Denoting Octal numbers in
C (with the
prefix 0):
- A number that starts with the prefix 0 (ZERO) is considered to use the Octal Number System as representation
Example:
0xxxxxxxx = the Octal number xxxxxxxx Example: 011 = 9 decimal (8 + 1)
- Example:
int main( int argc, char* argv[] ) { char a = 011; /* 11 Octal = 8 + 1 = 9 decimal */ printf( "a = %d\n", a ); a = 0101; /* 101 Octal = 64 + 1 = 65 decimal */ printf( "a = %d\n", a ); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc octal1.c
- To run: ./a.out
- Hexadecimal numbers uses
base 16 is the representation
Example:
Representation Value represented --------------------------------------------------- 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 A 10 B 11 C 12 D 13 E 14 F 15 10 16 11 17 12 18 ... ... 23 2*16 + 3 = 35
- Denoting Hexadecimal numbers in
C (with the
prefix 0x):
- A number that starts with the prefix 0x (ZERO x) is considered to use the Hexadecimal Number System as representation
Example:
0xaaaaa = the Hexadecimal number aaaaa Example: 0x1A = 26 decimal (16 + 10)
- Example:
int main( int argc, char* argv[] ) { int a = 0x1A; /* 1A Hexadecimal = 16 + 10 = 26 decimal */ printf( "a = %d\n", a ); a = 0x10A; /* 101 Hexadecimal = 256 + 10 = 266 decimal */ printf( "a = %d\n", a ); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc hexadec1.c
- To run: ./a.out
- Clear a certain bit in a
bit pattern
- Suppose the variable a
contains a bit pattern:
a = 1010...x...1101
- Problem:
- Clear the bit x to the value 1 without changing all other bits in the pattern.
- We can clear the bit
x inside the
bit pattern to 0 using
the AND operation with
the following
specific pattern:
a = 1010...x...1101 1111..101..1111 AND --------------- 1010...0...1101
Note:
- The bit pattern
1111...101...1111can be obtained using:
NOT ( 0000...010...0000 )
- Suppose the variable a
contains a bit pattern:
- Example:
clear
the 4th bit
and the 2nd bit in
a bit pattern
int main( int argc, char* argv[] ) { char a = 31; /* a = 00011111 (= 31) */ a = a & (~16); /* Now: a = 00001111 (= 15) */ printf( "a = %d\n", a ); a = a & (~4); /* Now: a = 00001011 (= 11) */ printf( "a = %d\n", a ); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc bit-op3.c
- To run: ./a.out
- Flipping a bit:
- Flipping a bit = changing a 0 bit to 1 or changing a 1 bit to 0
- Flip a certain bit in a
bit pattern
- Suppose the variable a
contains a bit pattern:
a = 1010...x...1101
- Problem:
- Flip the bit x without changing all other bits in the pattern.
- We can flip the bit
x inside the
bit pattern using
the XOR operation with
the following
specific pattern:
a = 1010...x...1101 0000..010..0000 XOR --------------- 1010...x...1101
- Suppose the variable a
contains a bit pattern:
- Example:
flip
the 4th bit
in
a bit pattern OFF and ON
int main( int argc, char* argv[] ) { char a = 31; /* a = 00011111 (= 31) */ a = a ^ 16; /* Now: a = 00001111 (= 15) */ printf( "a = %d\n", a ); a = a ^ 16; /* Now: a = 00011111 (= 31) */ printf( "a = %d\n", a ); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc bit-op5.c
- To run: ./a.out
- Testing a certain bit in a
bit pattern
- Suppose the variable a
contains a bit pattern:
a = 1010...x...1101
- Problem:
- Test whether the bit x is 1 or not without changing any bit in the pattern.
- We can test the bit
x inside the
bit pattern by
first
filtering out
this bit using
the AND operation with
the following
specific pattern:
a = 1010...x...1101 0000..010..0000 AND --------------- 0000...x...0000and then:
- Testing whether the result is equal to 0 or not.
- Suppose the variable a
contains a bit pattern:
- Example: test
whether the 3rd bit in
a bit pattern is set or reset
int main( int argc, char* argv[] ) { char a = .....; /* Any bit pattern */ if ( (a & 0b00001000) == 0 ) /* Test is 3rd bit is set */ printf( "bit is 0\n" ); else printf( "bit is 1\n" ); }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: gcc bit-op4.c
- To run: ./a.out
- These bit wise operators are
also defined in Java.
- They are often omitted in introduction courses because they are not used in program at the introduction level.