C-Language-Series-#17-Bitwise-Operators-in-C

Welcome back to our C Language Series! In this seventeenth installment, we're diving deep into a fascinating and powerful set of operators: Bitwise Operators. These operators allow you to manipulate individual bits within integer types, providing fine-grained control over data at the lowest level. While they might seem intimidating at first, mastering bitwise operations unlocks efficiency and capabilities crucial for tasks like low-level programming, data compression, encryption, and optimizing certain algorithms.

Unlike arithmetic or logical operators that work on entire values, bitwise operators operate directly on the binary representations of numbers. Let's explore each one with clear explanations and practical C code examples.

Bitwise AND (&)

The Bitwise AND operator compares corresponding bits of two operands. If both bits are 1, the resulting bit is 1; otherwise, it's 0.

Truth Table:

• 0 & 0 = 0
• 0 & 1 = 0
• 1 & 0 = 0
• 1 & 1 = 1

It's commonly used to clear specific bits or to check if a particular bit is set.

Example: Clearing a bit and checking a bit

#include <stdio.h>

int main() {
    int a = 12;  // Binary: 0000 1100
    int b = 7;   // Binary: 0000 0111
    int result_and = a & b; // Binary: 0000 0100 (Decimal: 4)

    printf("a = %d (0x%X)\n", a, a);
    printf("b = %d (0x%X)\n", b, b);
    printf("a & b = %d (0x%X)\n\n", result_and, result_and);

    // Practical use: Check if a specific bit is set
    int flags = 0b10110010; // Example flags (using binary literal, C99 onwards)
    int mask = 0b00000010;  // Mask to check the 2nd bit (from right, 0-indexed)

    if ((flags & mask) != 0) {
        printf("The 2nd bit (0-indexed) in flags is set.\n");
    } else {
        printf("The 2nd bit (0-indexed) in flags is not set.\n");
    }

    // Practical use: Clear a specific bit
    int num_to_clear = 0b11011011; // Clear the 3rd bit (0-indexed)
    int clear_mask = ~(1 << 3);   // Create a mask like 11110111
    int cleared_num = num_to_clear & clear_mask;
    printf("Original num: %d (0x%X)\n", num_to_clear, num_to_clear);
    printf("Cleared num (3rd bit): %d (0x%X)\n", cleared_num, cleared_num);


    return 0;
}

Output Explanation:

a = 12 (0xC)
b = 7 (0x7)
a & b = 4 (0x4)

The 2nd bit (0-indexed) in flags is set.
Original num: 219 (0xDB)
Cleared num (3rd bit): 211 (0xD3)

Bitwise OR (|)

The Bitwise OR operator compares corresponding bits of two operands. If at least one of the bits is 1, the resulting bit is 1; otherwise, it's 0.

Truth Table:

• 0 | 0 = 0
• 0 | 1 = 1
• 1 | 0 = 1
• 1 | 1 = 1

It's commonly used to set specific bits or to combine flag values.

Example: Setting a bit and combining flags

#include <stdio.h>

int main() {
    int a = 12;  // Binary: 0000 1100
    int b = 7;   // Binary: 0000 0111
    int result_or = a | b; // Binary: 0000 1111 (Decimal: 15)

    printf("a = %d (0x%X)\n", a, a);
    printf("b = %d (0x%X)\n", b, b);
    printf("a | b = %d (0x%X)\n\n", result_or, result_or);

    // Practical use: Set a specific bit
    int flags = 0b10110010; // Original flags
    int set_mask = 0b00001000; // Mask to set the 3rd bit (0-indexed)
    int new_flags = flags | set_mask;

    printf("Original flags: %d (0x%X)\n", flags, flags);
    printf("New flags (3rd bit set): %d (0x%X)\n", new_flags, new_flags);

    return 0;
}

Output Explanation:

a = 12 (0xC)
b = 7 (0x7)
a | b = 15 (0xF)

Original flags: 178 (0xB2)
New flags (3rd bit set): 186 (0xBA)

Bitwise XOR (^)

The Bitwise XOR (Exclusive OR) operator compares corresponding bits of two operands. If the bits are different, the resulting bit is 1; if they are the same, it's 0.

Truth Table:

• 0 ^ 0 = 0
• 0 ^ 1 = 1
• 1 ^ 0 = 1
• 1 ^ 1 = 0

XOR has some unique properties: A ^ A = 0, A ^ 0 = A, and A ^ B ^ B = A. This makes it useful for swapping numbers without a temporary variable, simple encryption/decryption, and detecting changes.

Example: Swapping numbers and simple encryption

#include <stdio.h>

int main() {
    int a = 12;  // Binary: 0000 1100
    int b = 7;   // Binary: 0000 0111
    int result_xor = a ^ b; // Binary: 0000 1011 (Decimal: 11)

    printf("a = %d (0x%X)\n", a, a);
    printf("b = %d (0x%X)\n", b, b);
    printf("a ^ b = %d (0x%X)\n\n", result_xor, result_xor);

    // Practical use: Swapping numbers without a temp variable
    int x = 5, y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    x = x ^ y; // x becomes 5 ^ 10 (binary 0101 ^ 1010 = 1111, decimal 15)
    y = x ^ y; // y becomes (5 ^ 10) ^ 10 = 5 (original x)
    x = x ^ y; // x becomes (5 ^ 10) ^ 5 = 10 (original y)
    printf("After swap: x = %d, y = %d\n", x, y);

    return 0;
}

Output Explanation:

a = 12 (0xC)
b = 7 (0x7)
a ^ b = 11 (0xB)

Before swap: x = 5, y = 10
After swap: x = 10, y = 5

Bitwise NOT (~) - One's Complement

The Bitwise NOT operator is a unary operator, meaning it operates on a single operand. It inverts all the bits of its operand: 0s become 1s, and 1s become 0s.

For signed integers, this operation typically results in -(x + 1) due to two's complement representation. For example, ~5 will be -6.

Example: Inverting bits

#include <stdio.h>

int main() {
    unsigned char a = 5; // Binary: 0000 0101 (assuming 8-bit char)
    // For unsigned char, ~a results in 1111 1010
    unsigned char result_not = ~a; 

    printf("unsigned char a = %u (0x%X)\n", a, a);
    printf("~a (unsigned char) = %u (0x%X)\n\n", result_not, result_not);

    int b = 5; // Binary (assuming 32-bit int): 0...0101
    // For signed int, ~b results in 1...1010 (two's complement of -6)
    int result_not_int = ~b; 

    printf("int b = %d (0x%X)\n", b, b);
    printf("~b (int) = %d (0x%X)\n", result_not_int, result_not_int);

    return 0;
}

Output Explanation:

unsigned char a = 5 (0x5)
~a (unsigned char) = 250 (0xFA)

int b = 5 (0x5)
~b (int) = -6 (0xFFFFFFFA)

Note: The exact hexadecimal output for signed integers (like 0xFFFFFFFA) depends on the size of int on your system (e.g., 32-bit or 64-bit).

Left Shift (<<)

The Left Shift operator shifts all bits of the left operand to the left by the number of positions specified by the right operand. Vacated bits on the right are filled with zeros.

Shifting left by n positions is equivalent to multiplying the number by 2n (as long as no bits are shifted out of the most significant position, causing overflow).

Example: Multiplication by powers of 2

#include <stdio.h>

int main() {
    unsigned int a = 5; // Binary: 0000 0101
    unsigned int result_shift_1 = a << 1; // Binary: 0000 1010 (Decimal: 10)
    unsigned int result_shift_3 = a << 3; // Binary: 0010 1000 (Decimal: 40)

    printf("a = %u (0x%X)\n", a, a);
    printf("a << 1 = %u (0x%X)\n", result_shift_1, result_shift_1);
    printf("a << 3 = %u (0x%X)\n", result_shift_3, result_shift_3);

    return 0;
}

Output Explanation:

a = 5 (0x5)
a << 1 = 10 (0xA)
a << 3 = 40 (0x28)

Right Shift (>>)

The Right Shift operator shifts all bits of the left operand to the right by the number of positions specified by the right operand. The behavior of bits shifted in on the left depends on whether the operand is signed or unsigned.

• For unsigned integers, vacated bits on the left are filled with zeros (logical right shift).
• For signed integers, the behavior is implementation-defined. It can be filled with zeros (logical right shift) or with the sign bit (arithmetic right shift), preserving the sign. Most compilers perform an arithmetic right shift for signed types.

Shifting right by n positions is equivalent to dividing the number by 2n (for unsigned types, or positive signed types).

Example: Division by powers of 2

#include <stdio.h>

int main() {
    unsigned int a = 40; // Binary: 0010 1000
    unsigned int result_rshift_1 = a >> 1; // Binary: 0001 0100 (Decimal: 20)
    unsigned int result_rshift_3 = a >> 3; // Binary: 0000 0101 (Decimal: 5)

    printf("unsigned a = %u (0x%X)\n", a, a);
    printf("unsigned a >> 1 = %u (0x%X)\n", result_rshift_1, result_rshift_1);
    printf("unsigned a >> 3 = %u (0x%X)\n\n", result_rshift_3, result_rshift_3);

    int b = 40; // Binary: 0...0010 1000
    int result_signed_rshift_1 = b >> 1; // Decimal: 20
    int result_signed_rshift_3 = b >> 3; // Decimal: 5

    printf("signed b = %d (0x%X)\n", b, b);
    printf("signed b >> 1 = %d (0x%X)\n", result_signed_rshift_1, result_signed_rshift_1);
    printf("signed b >> 3 = %d (0x%X)\n\n", result_signed_rshift_3, result_signed_rshift_3);

    int negative_b = -40; // Binary (two's complement): e.g., ...11011000 (if 32-bit)
    int result_negative_rshift_1 = negative_b >> 1; // e.g., -20 (arithmetic shift)
    int result_negative_rshift_3 = negative_b >> 3; // e.g., -5 (arithmetic shift)

    printf("signed negative_b = %d (0x%X)\n", negative_b, negative_b);
    printf("signed negative_b >> 1 = %d (0x%X)\n", result_negative_rshift_1, result_negative_rshift_1);
    printf("signed negative_b >> 3 = %d (0x%X)\n", result_negative_rshift_3, result_negative_rshift_3);

    return 0;
}
```

unsigned a = 40 (0x28)
unsigned a >> 1 = 20 (0x14)
unsigned a >> 3 = 5 (0x5)

signed b = 40 (0x28)
signed b >> 1 = 20 (0x14)
signed b >> 3 = 5 (0x5)

signed negative_b = -40 (0xFFFFFFD8)
signed negative_b >> 1 = -20 (0xFFFFFFEC)
signed negative_b >> 3 = -5 (0xFFFFFFFB)