Bitwise Operators in C: AND, OR, XOR, Shift & Complement

What You'll Learn in This Tutorial

• Bitwise AND Operator (&)
• Bitwise OR Operator (|)
• Bitwise XOR Operator (^)
• Left Shift and Right Shift Operators
• One's Complement Operator (~)
• Practice Questions

Bitwise operators in C are special operators that perform operations at the data bit level. When operations are performed on individual bits, it's called bit-level programming. These operations are much faster than normal arithmetic operations because they're directly supported by the CPU's arithmetic logic unit (ALU).

C language uses six types of bitwise operators:

• & — Bitwise AND Operator
• | — Bitwise OR Operator
• ^ — Bitwise XOR (Exclusive OR) Operator
• << — Bitwise Left Shift Operator
• >> — Bitwise Right Shift Operator
• ~ — One's Complement Operator

Bitwise Operators in C - Quick Overview

1. Bitwise AND Operator (&)

The bitwise AND operator is denoted by the single ampersand sign (&). Two integer operands are written on both sides of the operator. If the corresponding bits of both operands are 1, then the output is 1; otherwise, the output is 0.

Example: We have two variables a = 5 and b = 3.

• a = 0101 (binary)
• b = 0011 (binary)
• a & b = 0001 = 1 (decimal)

Result: 5 & 3 = 1

#include <stdio.h>

int main() {
    int a = 5, b = 3, c;
    c = a & b;
    printf("The output of AND operator a&b is %d\n", c);
    return 0;
}

The output of AND operator a&b is 1

2. Bitwise OR Operator (|)

The bitwise OR operator is represented by a single vertical sign (|). If the bit value of either operand is 1, then the output is 1; otherwise, it's 0. This operator returns 1 when at least one bit is 1.

Example: If a = 5 and b = 3, then a | b = 7.

#include <stdio.h>

int main() {
    int a = 5, b = 3, c;
    c = a | b;
    printf("The output of OR operator a|b is %d\n", c);
    return 0;
}

The output of OR operator a|b is 7

3. Bitwise XOR Operator (^)

The bitwise XOR (exclusive OR) operator is denoted by ^. It returns 1 if the bits in the operands are different, and 0 if they're the same.

XOR is the most underrated operator. It's incredibly useful for swapping values without a temporary variable, encrypting data, and finding unique elements in arrays.

Example: 10 = 00001010 (binary), 12 = 00001100 (binary)

• 00001010 ^ 00001100 = 00000110 = 6 (decimal)

#include <stdio.h>

int main() {
    int a = 10, b = 12;
    printf("XOR result: %d\n", (a ^ b));
    return 0;
}

XOR result: 6

4 & 5. Left Shift and Right Shift Operators

Bitwise Left Shift Operator (<<)

The left shift operator shifts all bits towards the left by a specified number of positions. Vacated positions on the right are filled with 0. Each left shift doubles the value.

Syntax: operand << n
Where n is the number of bits to shift.

Example: 5 << 2 = 20

• 5 = 0101 (binary)
• 0101 << 2 = 00010100 = 20 (decimal)

Bitwise Right Shift Operator (>>)

The right shift operator shifts all bits towards the right by a specified number of positions. Each right shift halves the value (ignoring the fractional part).

Example: 5 >> 1 = 2

• 5 = 0101 (binary)
• 0101 >> 1 = 0010 = 2 (decimal)

6. One's Complement Operator (~)

The one's complement operator is a unary operator that flips all bits: 1 becomes 0, and 0 becomes 1. For any integer n, ~n = -(n+1) due to two's complement representation.

Example: 35 = 00100011 (binary)

• ~00100011 = 11011100 = -36 (decimal)

Important: The bitwise complement of 35 is -36, not 220, because C uses two's complement representation.

Truth Table for Bitwise Operators

Complete C Program to Demonstrate All Bitwise Operators

#include <stdio.h>

int main() {
    unsigned char a = 5, b = 9;
    
    printf("a = %d, b = %d\n", a, b);
    printf("a & b = %d\n", a & b);
    printf("a | b = %d\n", a | b);
    printf("a ^ b = %d\n", a ^ b);
    printf("~a = %d\n", ~a);
    printf("b << 1 = %d\n", b << 1);
    printf("b >> 1 = %d\n", b >> 1);
    
    return 0;
}

a = 5, b = 9
a & b = 1
a | b = 13
a ^ b = 12
~a = -6
b << 1 = 18
b >> 1 = 4

Common Mistakes to Avoid

• Confusing & with && — & is bitwise AND, && is logical AND. They are not the same.
• Using bitwise operators on floats — Bitwise operators only work on integer types (int, char, short, long).
• Ignoring operator precedence — Bitwise operators have lower precedence than arithmetic operators.
• Sign bit issues with right shift — Right shift on signed integers may preserve the sign bit on some systems.
• Overflow with left shift — Shifting too far can lose bits or cause undefined behavior.

Why Bitwise Operators Matter

• Performance: Bitwise operations are up to 10x faster than arithmetic operations
• Hardware Programming: Essential for embedded systems, device drivers, and microcontroller programming
• Career: Essential for FAANG, embedded systems, game dev, and cybersecurity roles
• Security: Used in encryption algorithms, hashing, and checksum calculations

Frequently Asked Questions

Further Reading

• Bitwise operators — cppreference.com
• ISO C Standard — ISO.org
• GCC Documentation — GNU Project

Related Tutorials

• Operators and Expressions in C
• Logical Operators in C
• Relational Operators in C
• Arithmetic Operators in C
• Assignment Operators in C
• Increment and Decrement Operators