Master Bitwise Operations: Essential Tricks for Faster Code

Introduction

Bitwise operations work directly on the binary representation of integers, providing highly efficient data processing for tasks such as counting bits, swapping values, and managing flags.

Basic Concepts

The primary bitwise operators are: & (AND) | (OR) ^ (XOR) ~ (NOT) << (left shift) >> (right shift)

Common Bitwise Tricks

Determine Odd or Even

Use x & 1. The result is 0 for even numbers and 1 for odd numbers.

Swap Two Numbers Without Extra Space

x ^= y;
y ^= x;
x ^= y;

Clear the Lowest Set Bit

Expression x & (x - 1) turns off the least‑significant 1‑bit of x. This is useful for counting set bits because each iteration removes one 1.

Get the Lowest Set Bit

Expression x & -x isolates the least‑significant 1‑bit of x.

Practical Applications

Fast Bit Count

Count the number of 1s in an integer by repeatedly clearing the lowest set bit:

int countBits(int x) {
    int count = 0;
    while (x != 0) {
        x = x & (x - 1); // clear lowest set bit
        count++;
    }
    return count;
}

Permission Management Using Bit Flags

Assign each permission a distinct bit and store the combined permissions in a single integer.

READ = 0x1 // 0001

WRITE = 0x2 // 0010

EXECUTE= 0x4 // 0100

ADMIN = 0x8 // 1000

#include <stdio.h>
#define READ   0x1   // 0001
#define WRITE  0x2   // 0010
#define EXECUTE 0x4  // 0100
#define ADMIN  0x8   // 1000

// Check permission
int has_permission(int permissions, int permission) {
    return permissions & permission;
}

// Set permission
void set_permission(int *permissions, int permission) {
    *permissions |= permission;
}

// Remove permission
void remove_permission(int *permissions, int permission) {
    *permissions &= ~permission;
}

int main() {
    int myPermissions = 0; // no permissions initially
    set_permission(&myPermissions, READ);
    set_permission(&myPermissions, WRITE);
    printf("Permissions after setting Read and Write: %d
", myPermissions);
    if (has_permission(myPermissions, READ)) {
        printf("User has Read permission.
");
    }
    remove_permission(&myPermissions, WRITE);
    printf("Permissions after removing Write: %d
", myPermissions);
    return 0;
}

Analysis of Permission Operations

Set permission : |= turns the target bit on.

Check permission : & tests whether a specific bit is set.

Remove permission : &= combined with ~ clears the target bit.

Conclusion

Bitwise techniques such as the ones described enable fast, compact, and scalable solutions for low‑level tasks like bit counting and flag management. Mastery of these patterns leads to more efficient and maintainable code.