C Bitwise Operators

C Bitwise Operators

Note: This is a more advanced topic in C. If you are new to programming, don't worry if it feels tricky at first - bitwise operators are mainly used in special cases like system programming, hardware control, or performance optimizations.

In C, bitwise operators let you work directly with the bits (the 1s and 0s) that make up numbers in binary form.

Every integer in a computer is stored in binary, which means it is represented using bits (binary digits) that are either 0 or 1. Bitwise operators allow you to compare, combine, shift, or flip these bits.

List of Bitwise Operators

Binary Example

Let's start with two integers:

int a = 6;  // 0110 in binary
int b = 3;  // 0011 in binary

Here's how different bitwise operators work on these values:

Decimal and Binary Values

Here is how the decimal numbers 0 to 12 look in binary (with 16 bits):

 0 = 0000000000000000
 1 = 0000000000000001
 2 = 0000000000000010
 3 = 0000000000000011
 4 = 0000000000000100
 5 = 0000000000000101
 6 = 0000000000000110
 7 = 0000000000000111
 8 = 0000000000001000
 9 = 0000000000001001
10 = 0000000000001010
11 = 0000000000001011
12 = 0000000000001100

Visualize Bitwise Operators

Choose an operator below to see how it works on a = 6 and b = 3, bit by bit (only the last 8 bits are shown):

Bitwise AND (&)

The & operator compares each bit and returns 1 only if both bits are 1.

int a = 6;   // 0110
int b = 3;   // 0011

int result = a & b;
printf("Result: %d\n", result); // 2 (0010)

Bitwise OR (|)

The | operator sets a bit to 1 if either bit is 1.

int a = 6;   // 0110
int b = 3;   // 0011

int result = a | b;
printf("Result: %d\n", result); // 7 (0111)

Bitwise XOR (^)

The ^ operator returns 1 only when the bits are different.

int a = 6;   // 0110
int b = 3;   // 0011

int result = a ^ b;
printf("Result: %d\n", result); // 5 (0101)

Bitwise NOT (~)

The ~ operator inverts each bit (0 becomes 1 and 1 becomes 0).

int a = 5; // 00000101

int result = ~a;
printf("Result: %d\n", result); // -6 on most systems

Left Shift (<<)

The << operator shifts bits to the left and fills in 0s on the right. Each shift to the left multiplies the number by 2, so a << 2 multiplies it by 4.

int a = 3; // 00000011

int result = a << 2;
printf("Result: %d\n", result); // 12 (3 * 4)

Right Shift (>>)

The >> operator shifts bits to the right. Each shift to the right divides the number by 2, so a >> 2 divides it by 4. For negative numbers, the result can be different on different systems.

int a = 12; // 00001100

int result = a >> 2;
printf("Result: %d\n", result); // 3 (12 / 4)

Real-Life Example: Flags and Permissions

Bitwise operators are often used to store multiple options in a single integer, using flags.

#define READ  1  // 0001
#define WRITE 2  // 0010
#define EXEC  4  // 0100

int permissions = READ | WRITE;  // user can read and write

if (permissions & READ) {
  printf("Read allowed\n");
}
if (permissions & WRITE) {
  printf("Write allowed\n");
}
if (permissions & EXEC) {
  printf("Execute allowed\n");
}

In this example, the user has both READ and WRITE permissions, but not EXEC.

permissions is 0011. permissions & READ is 0011 & 0001, which gives 0001. That is not 0, so the condition is true. permissions & EXEC is 0011 & 0100, which gives 0000 (false), so "Execute allowed" is not printed.

Summary

• Bitwise operators work on individual bits of integers
• &: AND - both bits must be 1
• |: OR - either bit can be 1
• ^: XOR - only one bit is 1
• ~: NOT - flips all bits
• <<: Left shift - multiplies by powers of 2
• >>: Right shift - divides by powers of 2