Bitwise operations in C are used to implement masking of variables, produce logical AND’s, logical OR’s, XOR operations on two variables, the occasional NOT, and even some bit shifting. The operations are called bitwise operations because each operation is done bit by bit for each variable.

Here are the most common and supported bitwise operations that C provides.

Contents

### Bitwise AND Operation In C

The AND operation, also known as a conjunction is true if and only if both values are true. The operator is a single** & ** ampersand sign in C. So for example:

`a & b` |

To produce a compound assignment where ‘a’ receives the value of “a **&** b” we can do:

`a &= b` |

An example of how the bitwise operation takes place:

1 2 3 | 0101 (5) AND 0011 (3) = 0001 (1) |

Working from right to left we produce each compare vertically, as if we were adding two large numbers. So, 1 & 1 = 1, 0 & 1 = 0, 1 & 0 = 0, 0 & 0 = 0. Thus 0001.

### Bitwise OR Operation in C

The OR operation, aka the disjunction is true if at least one of its operands is true. In C its symbol is a single bar **|** or affectionately known as a pipe in Linux/Unix circles.

`a | b` |

To produce a compound assignment where ‘a’ receives the value of “a **|** b” we can do:

`a |= b` |

An example of how the OR operation takes place:

1 2 3 | 0111 (7) OR 0101 (5) = 0111 (7) |

Execution occurs in the same manner mentioned under the AND operation.

### Bitwise NOT Operation In C

The bitwise not symbol in C is the tilde, **~** symbol.

`a = ~b` |

The not just inverses each bit within your variable:

1 2 | NOT 0011 (2) = 1100 (12) |

So in this case, 2 becomes twelve as we flip the bits.

### Bitwise XOR Operation In C

An exclusive disjunction or XOR is true if one but not both of its operands is true. This is sometimes used for basic encryption.

To produce an XOR in C we use the **^** symbol, also known as a carat.

`a ^ b` |

To produce a compound assignment where ‘a’ receives the value of “a **^** b” we can do:

`a ^= b` |

For example:

1 2 3 | 0101 (5) XOR 0011 (3) = 0110 (6) |

So following the same methodology above, we XOR 5 and 3 and receive 6.

### Bit-shifting Operations In C

The bit shifting that occurs in C is known as a logical shift because the bits that are shifted out are lost, rather than circulating to the front of that variable. To execute a shift in C, we use ** << ** or ** >> ** for left and right shift respectively.

The programmer may specify how many bits to shift by providing a number, for example:

a = b << 2; |

This example will shift ‘b’ two bits to left, and assign that value to ‘a’. To shift to the right instead, use the ** >> ** symbols.

What will happen is, if our variable contained 2 in it:

1 2 3 | 0010 (2) // We execute the shift two places and notice 1 moved left two spots 1000 (8) |

Bitwise operations on older systems were faster for addition and subtraction operations and largely faster than multiplication and division, however, on today’s architectures bitwise operations are essentially as efficient, with multiplication and division still requiring more operations.