Bitwise operations in C

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 (as shown in the table above) of the bits in each position of a number in its binary form.

For instance, working with a byte (the char type):

11001000 & 10111000 -------- = 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 XOR (exclusive or) performs a logical XOR function, which is equivalent to adding two bits and discarding the carry. The result is zero only when we have two zeroes or two ones. XOR 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 "~" / ones' complement (unary)

The ones' 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 "!".

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 (i.e. the right operand). 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 (zeros). When performed on a signed type, the result is technically undefined and compiler dependant, however most compilers will perform an arithmetic shift, 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

0001010001101001 - Decimal 5225 equivalent in binary0001010001101001 - 5225 right shift 00000101000110100 - 5225 right shift 10000010100011010 - 5225 right shift 20000001010001101 - 5225 right shift 30000000101000110 - 5225 right shift 40000000010100011 - 5225 right shift 5

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, which multiplies the original number by 4 i.e. 16 */

A simple addition program

The following program adds two operands using AND, XOR and left shift (<<).

Bitwise assignment operators

C provides a compound assignment operator for each binary arithmetic and bitwise operation (i.e. each operation which accepts two operands). 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.

Example:

The output of the above program will be

Bitwise AND passed, was: 8 expected: 8Bitwise OR passed, was: E expected: EBitwise XOR passed, was: 6 expected: 6Bitwise NOT passed, was: FE expected: FELogical AND passed, was: 1 expected: 1Logical AND passed, was: 0 expected: 0Logical AND passed, was: 0 expected: 0Logical AND passed, was: 0 expected: 0Logical OR passed, was: 1 expected: 1Logical OR passed, was: 1 expected: 1Logical OR passed, was: 1 expected: 1Logical OR passed, was: 0 expected: 0Logical XOR passed, was: 0 expected: 0Logical XOR passed, was: 1 expected: 1Logical XOR passed, was: 1 expected: 1Logical XOR passed, was: 0 expected: 0Logical NOT passed, was: 1 expected: 1Logical NOT passed, was: 0 expected: 0