Bitwise operators with examples in Cpp with code examples:
Byte is the lowest level at which we can access data; there is no "bit" type.
And also it is not possible to perform operations on a single bit  every bitwise operator will be applied to, at a minimum, an entire byte at a time.
Using bitwise operators, it is possible to write functions that allow us to compact 8 Booleans into a single bytesized variable, enabling significant memory savings at the expense of more complex code. In the past, this was a good tradeoff. Today, at least for application programming, it is probably not.
bitwise Complement: The bitwise complement operator, the tilde, ~, flips every bit. It is also called as twiddle, and the bitwise complement twiddles every bit:
This turns out to be a great way of finding the largest possible value for an unsigned number
bitwise AND: The bitwise AND operator is a single ampersand: &:
bitwise OR: The bitwise OR operator is a :
bitwise Exclusive OR (XOR): if either one or the other of the inputs is a 1 the exclusiveor operator returns 1, but not if both are. That is, if both inputs are 1 or both inputs are 0, it returns 0.
Bitwise exclusiveor, with the operator of a carrot, ^, performs the exclusiveor operation on each pair of bits.
Suppose, we have some bit, either 1 or 0, that we'll call Z. When we take Z XOR 0, then we always get Z back: if Z is 1, we get 1, and if Z is 0, we get 0. On the other hand, when we take Z XOR 1, we flip Z. If Z is 0, we get 1; if Z is 1, we get 0:
• TestBits ^ 0 : No change
• TestBits ^ 1 : Flip
It's a kind of selective twiddle(~).So, if we do XOR against 111...1111, all the bits of TestBits flipped. Which is the equivalent of doing twiddle(~).
right shift operator (>>): Moving all the bits of a number a specified number of places to the right. Note that a bitwise rightshift will be the equivalent of integer division by 2:
00000101(5) >> 1

00000010(2)
left shift operator (<<): Moving all the bits of a number a specified number of places to the left:
Suppose we have number 8 written in binary 00001000. If we wanted to shift it to the left 2 places, we'd end up with 00100000; everything is moved to the left two places, and zeros are added as padding. This is the number 32:
Actually, left shifting is the equivalent of multiplying by a power of two:
More specifically:
Set a bit (where n is the bit number, and 0 is the least significant bit):
unsigned char Testbit = (1 << n);
Try tot understand the below Example:
Byte is the lowest level at which we can access data; there is no "bit" type.
And also it is not possible to perform operations on a single bit  every bitwise operator will be applied to, at a minimum, an entire byte at a time.
Using bitwise operators, it is possible to write functions that allow us to compact 8 Booleans into a single bytesized variable, enabling significant memory savings at the expense of more complex code. In the past, this was a good tradeoff. Today, at least for application programming, it is probably not.
Representation
of the Symbol

Name of the Function 
Symbol
Description

~

Complement

Bit n of ~a is the
opposite of bit n of a

&

Bitwise And

Bit n of a&b is
1 if bit n of a and bit n of b is 1.



Bitwise Or

Bit n of ab is 1 if
bit n of a or bit n of b is 1.

^

Bitwise Exclusive Or

Bit n of a^b is 1 if
bit n of a or bit n of b is 1 but not if both are
1.
a^b = (ab) & !(a&b) : either a or b but not both 
>>

Right Shift (divide by 2)

Bit n of a>>s
is bit ns of a.

<<

Left Shift (multiply by 2)

Bit n of a<<s
is bit n+s of a.

bitwise Complement: The bitwise complement operator, the tilde, ~, flips every bit. It is also called as twiddle, and the bitwise complement twiddles every bit:
This turns out to be a great way of finding the largest possible value for an unsigned number
unsigned int test = ~0;
bitwise AND: The bitwise AND operator is a single ampersand: &:
01001000 & 10111000 =  00001000
bitwise OR: The bitwise OR operator is a :
01001000  10111000 =  11111000
bitwise Exclusive OR (XOR): if either one or the other of the inputs is a 1 the exclusiveor operator returns 1, but not if both are. That is, if both inputs are 1 or both inputs are 0, it returns 0.
Bitwise exclusiveor, with the operator of a carrot, ^, performs the exclusiveor operation on each pair of bits.
01110010 ^ 10101010  11011000
Suppose, we have some bit, either 1 or 0, that we'll call Z. When we take Z XOR 0, then we always get Z back: if Z is 1, we get 1, and if Z is 0, we get 0. On the other hand, when we take Z XOR 1, we flip Z. If Z is 0, we get 1; if Z is 1, we get 0:
• TestBits ^ 0 : No change
• TestBits ^ 1 : Flip
It's a kind of selective twiddle(~).So, if we do XOR against 111...1111, all the bits of TestBits flipped. Which is the equivalent of doing twiddle(~).
right shift operator (>>): Moving all the bits of a number a specified number of places to the right. Note that a bitwise rightshift will be the equivalent of integer division by 2:
00000101(5) >> 1

00000010(2)
left shift operator (<<): Moving all the bits of a number a specified number of places to the left:
[myVariable]<<[number of places]
Suppose we have number 8 written in binary 00001000. If we wanted to shift it to the left 2 places, we'd end up with 00100000; everything is moved to the left two places, and zeros are added as padding. This is the number 32:
00001000(8) << 2  00100000(32)
Actually, left shifting is the equivalent of multiplying by a power of two:
val << num  val * (1 << num)
More specifically:
8 << 2  8 * (1 << 2)  8 * (2**2)  32
Set a bit (where n is the bit number, and 0 is the least significant bit):
unsigned char Testbit = (1 << n);
Try tot understand the below Example:
Testbit 1 0 0 0 0 0 0 0 Testbit = (1 << 1) = 1 0 0 0 0 0 1 0 Testbit = (1 << 3) = 1 0 0 0 1 0 0 0 Testbit = (1 << 5) = 1 0 1 0 0 0 0 0Clear a bit:
unsigned char TestBit &= ~(1 << n); See the sample below:TestBit 1 1 1 1 1 1 1 1 TestBit &= ~(1 << 1) = 1 1 1 1 1 1 0 1 TestBit &= ~(1 << 3) = 1 1 1 1 0 1 1 1 TestBit &= ~(1 << 5) = 1 1 0 1 1 1 1 1See the another sample for more understanding: Write a macro with two arguments a and pos, where a is a byte and the pos specifies a bit position of the byte. The macro should clear the particular bit position in the given byte.#include <stdio.h> using namespace std; #define CLEARBIT(x, y) (x &= ~(1 << num) ) int main() { /* 'z': decimal value 122 (=01111010) */ char val = 'z'; /* clearing the 5th bit */ char aOut = CLEARBIT(val, 5); /* aOut = 'Z': decimal value 90 (=01011010) */ printf("aOut=%c\n", aOut); return 0; }Toggle a bit:unsigned char Testbit ^= (1 << num)Let us understand the below Example:Testbit 1 0 0 1 1 0 1 1 Testbit ^= (1 << 1) = 1 0 0 1 1 0 0 1 Testbit ^= (1 << 3) = 1 0 0 1 0 0 1 1 Testbit ^= (1 << 5) = 1 0 1 1 1 0 1 1Test a bit:unsigned char Test = dVal & (1 << n); //dVal has the byte value.The right/left most byte: unsigned char ShiftRight= Result & 0xff; // right most byte which is also called as least significant. unsigned char ShiftLeft = (Result>>8) & 0xff; // left most byte which is also called as most significant. sign bit assuming 16 bit, 2byte short integer, two's complement:bool signbit = Result & 0x8000; // This is the sign bit
No comments:
Post a Comment