In the C programming language, operations can be performed on a bit level using bitwise
operators. Bitwise operations are contrasted by byte-level
operations which characterize the bitwise operators' logical counterparts, the AND,
OR and NOT operators. Instead of performing on individual bits, these operators perform
on strings of eight bits at a time. The reason for this is that a byte is normally the smallest
unit of addressable memory This applies to bitwise operators as well,
which means that even though they operate on only one bit at a time they cannot accept
anything smaller than a byte as their input.
Bitwise operators C provides six operators for bit manipulation.
Bitwise AND "&" The bitwise AND operator is a single ampersand:
&. It is just a representation of AND which does its work on the bits of the operands
rather than the truth value of the operands. Bitwise binary AND does the logical AND of
the bits in each position of a number in its binary form.
For instance, working with a byte:
11001110 & 10011000
= 10001000
The most significant bit of the first number is 1 and that of the second number is also
1 so the most significant bit of the result is 1; in the second most significant bit,
the bit of second number is zero, so we have the result as 0.
Bitwise OR "|" Similar to bitwise AND, bitwise OR only operates
at the bit level. Its result is a 1 if one of the either bits is 1 and zero only when
both bits are 0. Its symbol is '|' which can be called a pipe.
11001110 | 10011000
= 11011110
Bitwise XOR "^" The Bitwise EX-OR performs a logical EX-OR
function, equivalent to adding two bits, discarding the carry. The result is zero only when we
have 2 zeroes or ones to perform on. EX-OR can be used to toggle the bits between 1 and
0. Thus: i = i ^ 1 when used in a loop toggles its values between 1 and 0.
Bitwise NOT "~" / one's complement The one's complement or the bitwise complement
gets us the complement of a given number. Thus we get the bits inverted, for every bit
1 the result is bit 0 and conversely for every bit 0 we have a bit 1. This operation should
not be confused with logical negation "!". Summary of bitwise operators
Shift operators There are two bitwise shift operators. They
are: Right shift
Left shift Right shift >>
The symbol of right shift operator is >>. For its operation, it requires two operands. It
shifts each bit in its left operand to the right. The number following the operator decides
the number of places the bits are shifted. Thus by doing ch >> 3 all the bits will be
shifted to the right by three places and so on.
Example: If the variable ch contains the bit pattern
11100101, then ch >> 1 will produce the result 01110010, and ch >> 2 will produce 00111001.
Here blank spaces are generated simultaneously on the left when the bits are shifted to the
right. When performed on an unsigned type, the operation performed is a logical shift,
causing the blanks to be filled by 0s. When performed on a signed type, an arithmetic
shift is performed, causing the blank to be filled with the sign bit of the left operand.
Right shift can be used to divide a bit pattern by 2 as shown:
i = 14; Bit pattern 1110 j = i >> 1; here we have the bit pattern shifted
by 1 thus we get 111 = 7 which is 14/2
Right shift operator usage Typical usage of a right shift operator in
C can be seen from the following code. Example:
The output of the above program will be:
The decimal 5225 is equal to binary - 0001010001101001 5225 right shift 0 gives 0001010001101001
5225 right shift 1 gives 0000101000110100 5225 right shift 2 gives 0000010100011010
5225 right shift 3 gives 0000001010001101 5225 right shift 4 gives 0000000101000110
5225 right shift 5 gives 0000000010100011
Left shift << The symbol of left shift operator is <<. It
shifts each bit in its left-hand operand to the left by the number of positions indicated
by the right-hand operand. It works opposite to that of right shift operator. Thus by doing
ch << 1 in the above example we have 11001010. Blank spaces generated are filled up by zeroes
as above. Left shift can be used to multiply an integer
in multiples of 2 as in:
int i = 4; /* bit pattern equivalent is 100 */
int j = i << 2; /* makes it 10000 a multiple of 2 i.e. 16 */
A simple addition program The following program adds 2 operands using
AND, EX-OR and left shift.
Bitwise assignment operators C provides a compound assignment operator
for each binary arithmetic and bitwise operation. Each of the compound bitwise assignment operators
perform the appropriate binary operation and store the result in the left operand.
The bitwise assignment operators are as follows: Logical equivalents
Four of the bitwise operators have equivalent logical operators. They are equivalent in
that they have the same truth tables. However, logical operators treat each operand as having
only one value, either true or false, rather than treating each bit of an operand as an
independent value. Logical operators consider zero false and any nonzero value true. Another
difference is that logical operators perform short-circuit evaluation.
The table below matches equivalent operators and shows a and b as operands of the operators.
!= has the same truth table as ^ but unlike the true logical operators, by itself != is
not strictly speaking a logical operator. This is because a logical operator must treat
any nonzero value the same. To be used as a logical operator != requires that operands
be normalized first. A logical not applied to both operands won’t change the truth
table that results but will ensure all nonzero values are converted to the same value before
comparison. This works because ! on a zero always results in a one and ! on any nonzero
value always results in a zero. The example below shows that the truth tables
for these Bitwise and Logical operators are identical but also demonstrates how they act
on their operands differently. The need to normalize operands for != can be demonstrated
by introducing a char T2 = 0x02 and packing it in an array. Mixing T2 with T will show
them being treated the same unless the operand NOTs around != are removed.
Example:
The output of the above program will be:
Bitwise AND passed, was: 8 expected: 8 Bitwise OR passed, was: E expected: E
Bitwise XOR passed, was: 6 expected: 6 Bitwise NOT passed, was: FE expected: FE
Logical AND passed, was: 1 expected: 1 Logical AND passed, was: 0 expected: 0
Logical AND passed, was: 0 expected: 0 Logical AND passed, was: 0 expected: 0
Logical OR passed, was: 1 expected: 1 Logical OR passed, was: 1 expected: 1
Logical OR passed, was: 1 expected: 1 Logical OR passed, was: 0 expected: 0
Logical XOR passed, was: 0 expected: 0 Logical XOR passed, was: 1 expected: 1
Logical XOR passed, was: 1 expected: 1 Logical XOR passed, was: 0 expected: 0
Logical NOT passed, was: 1 expected: 1 Logical NOT passed, was: 0 expected: 0
See also Bit manipulation
Bitwise operation Operators in C and C++
Bitboard Boolean algebra
XOR swap algorithm XOR linked list
References
External links Bitwise Operators