Bitwise Operations in C: AND, OR, XOR, Shift, and Complement

Quick Refresher: Numbers as Bits

Before the operators, thirty seconds on binary. Every integer is stored as bits — 1s and 0s:

Each position is a power of two (8, 4, 2, 1 reading left to right). That's all binary is: switches adding up. Now — the operators that manipulate them.

The Six Bitwise Operators

The key difference from logical operators: logical operators treat values as whole truths;bitwise operators compare bit by bit, position by position.

& — Bitwise AND: The Shared-Bit Finder

&compares each pair of bits and keeps 1 only wherebothare 1:

The classic use — testing whether a bit is ON:

This pattern —value & mask— is how embedded programmers check hardware status bits:is the sensor flag set? Is the device ready bit on?

| — Bitwise OR: The Bit Setter

|keeps 1 wherevereitherbit is 1:

The classic use — turning a bit ON without disturbing others:

This is how yousetflags: OR with a mask that has 1 exactly where you want to switch on. File permissions, hardware registers, game state flags — all use this.

^ — Bitwise XOR: The Difference Detector

^keeps 1 only where bitsdiffer:

XOR has two magical properties that power famous tricks:

The classic party trick — swapping without a temporary variable:

(It's a great interview demo, though in real code the temporary-variable version is clearer and equally fast.)

~ — Bitwise NOT: The Bit Flipper

~is unary — it flipseverybit, 1→0 and 0→1:

Wait — negative six?Welcome to two's complement: computers store negative numbers by flipping all bits and adding 1. The math works out to a tidy rule:

So~5is-6,~0is-1, and~(-3)is2. Confusing at first sight, perfectly logical underneath.

<< — Left Shift: The Doubling Machine

<<slides all bits left, filling the right side with zeros:

The rule:x << nmultiplies x by 2ⁿ.1 << 3is 8.3 << 2is 12. Shifting left is a lightning-fast multiplication trick — and it's also how youbuildbit masks:

>> — Right Shift: The Halving Machine

>>slides bits right, discarding what falls off:

The rule:x >> ndivides x by 2ⁿ (integer division). Bit 0 falling off is how you know the number was odd.

#include <stdio.h>
// each setting gets its own bit
#define BOLD(1 << 0) // 0001 = 1
#define ITALIC(1 << 1) // 0010 = 2
#define UNDERLINE(1 << 2) // 0100 = 4
#define STRIKE(1 << 3) // 1000 = 8
int main() {
    int style = 0;
    // nothing on
    style = style | BOLD;
    // turn bold ON
    style = style | UNDERLINE;
    // turn underline ON
    printf("Style flags: %d\n", style);
    // 5 (0101)
    if (style & BOLD) {
        printf("Text is bold\n");
        // runs
    }
    if (!(style & ITALIC)) {
        printf("Text is NOT italic\n");
        // runs
    }
    style = style & ~UNDERLINE;
    // turn underline OFF (AND with flipped mask)
    printf("After removing underline: %d\n", style);
    // 1
    style = style ^ BOLD;
    // TOGGLE bold with XOR
    printf("After toggling bold: %d\n", style);
    // 0
    return 0;
}

printf("%d\n", 4 & 2);
// 0 — bitwise: no shared bits (0100 & 0010)
printf("%d\n", 4 && 2);
// 1 — logical: both non-zero → true