Operators

Bitwise operators — deep dive

• Bitwise operators work on the binary representation of integer types (int, unsigned, etc.).
• They are used in flags, masks, compression, graphics, embedded systems, and interview puzzles.
• Know binary first: for example, 12 is 1100, 10 is 1010.

Bitwise AND, OR, XOR with examples

• AND (&): useful to test/clear bits. Example: n & 1 checks if n is odd.
• OR (|): useful to set bits. Example: flags | 0b0100 turns a flag on.
• XOR (^): useful to toggle bits and for “swap without temp” / find unique number tricks.

int a = 12; // 1100
int b = 10; // 1010

cout << (a & b) << "\n"; // 8  (1000)
cout << (a | b) << "\n"; // 14 (1110)
cout << (a ^ b) << "\n"; // 6  (0110)

int n = 7;
if (n & 1) cout << "odd\n"; // true

// toggle bit 1 (value 2): 7 ^ 2 => 5
cout << (7 ^ 2) << "\n";

Bitwise NOT and shifts

• ~a flips every bit. For signed int, the printed decimal value uses two’s complement — results can look “unexpected” unless you print bits carefully.
• Prefer unsigned types when teaching bit patterns to avoid signed-shift surprises.
• a << n shifts left by n positions (fills with 0 on the right).
• a >> n shifts right. For unsigned, fills with 0; for signed, behavior of the sign bit can be implementation-defined historically — use unsigned for portable bit logic.
• Shifting by a negative count or by ≥ width of the type is undefined behaviour.

#include <iostream>
#include <cstdint>
using namespace std;

int main() {
    uint8_t x = 0b00001100; // 12
    cout << int(x << 1) << "\n"; // 24 (00011000)
    cout << int(x >> 2) << "\n"; // 3  (00000011)

    uint8_t y = 0b00000101; // 5
    uint8_t flipped = uint8_t(~y); // low 8 bits: 11111010
    cout << int(flipped) << "\n"; // 250
    return 0;
}

Masks, flags, and practical bit patterns

• Set bit k: n = n | (1u << k)
• Clear bit k: n = n & ~(1u << k)
• Toggle bit k: n = n ^ (1u << k)
• Check bit k: (n & (1u << k)) != 0
• These four patterns cover most interview and embedded bit-flag tasks.

unsigned n = 0b0000;
n |= (1u << 1);          // set bit 1 -> 0010
n |= (1u << 3);          // set bit 3 -> 1010
bool on = (n & (1u << 3)) != 0; // true
n &= ~(1u << 1);         // clear bit 1 -> 1000
n ^= (1u << 3);          // toggle bit 3 -> 0000

Deeper operator rules (non-bitwise)

• Precedence: * / % bind tighter than + -; use parentheses when unsure.
• Do not modify the same scalar twice in one expression without a sequence point style guarantee — avoid i = i++.
• Prefer == for equality; a common bug is writing = inside conditions by mistake.
• sizeof is compile-time for most ordinary types/expressions and does not evaluate side effects in typical cases.