How to work with bitwise operators in C

Bitwise operators in C++ are essential for manipulating individual bits in data, providing efficient control in low-level programming, embedded systems, and algorithmic optimizations. The six main operators are: & (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift), and >> (right shift), all operating on integral types at the bit level. For example, with unsigned char a = 5 (00000101) and b = 3 (00000011), a & b yields 1 (00000001), a | b gives 7 (00000111), a ^ b results in 6 (00000110), ~a produces 250 (11111010 in 8-bit), a << 1 equals 10 (multiplication by 2), and a >> 1 equals 2 (division by 2). Common techniques include checking if a number is odd or even using n & 1, toggling the k-th bit with n ^= (1 << k), setting the k-th bit via n |= (1 << k), clearing it with n &= ~(1 << k), and extracting a bit using (n >> k) & 1. XOR can swap two values without a temporary variable: a ^= b; b ^= a; a ^= b;, though this may affect code clarity. Counting set bits can be done manually with a loop or using GCC’s __builtin_popcount(n). Important considerations include using unsigned types to ensure predictable right-shift behavior, being aware of integer promotion and sign extension, and respecting operator precedence—parentheses are crucial, as in (flags & MASK) == VALUE to avoid errors due to == having higher precedence than &. Shifting by negative amounts or beyond bit width causes undefined behavior. A practical application is managing flags: constants like READ = 1, WRITE = 2, EXECUTE = 4 allow combining permissions with |, checking with &, and removing with ~, a pattern common in system programming. In summary, bitwise operators offer fast, precise bit-level control when used carefully with proper type selection, parentheses, and clear documentation, making them powerful tools in performance-critical and hardware-related code.

Working with bitwise operators in C++ is essential when you need to manipulate individual bits in data, such as in low-level programming, embedded systems, optimization, or solving algorithmic problems. These operators work directly on the binary representation of integers. Here’s how to use them effectively.

Understanding the bitwise operators

C++ provides six main bitwise operators:

• & (AND) – Returns 1 if both bits are 1.
• | (OR) – Returns 1 if at least one bit is 1.
• ^ (XOR) – Returns 1 if the bits are different.
• ~ (NOT) – Inverts all bits (1 becomes 0, 0 becomes 1).
• << (Left shift) – Shifts bits to the left, multiplying by powers of 2.
• >> (Right shift) – Shifts bits to the right, dividing by powers of 2 (arithmetic shift for signed, logical for unsigned).

These operators work on integral types (int, char, long, etc.) and are evaluated bit by bit.

For example:

unsigned char a = 5;  // 00000101
unsigned char b = 3;  // 00000011

cout << (a & b) << endl;  // 1 → 00000001
cout << (a | b) << endl;  // 7 → 00000111
cout << (a ^ b) << endl;  // 6 → 00000110
cout << (~a) << endl;     // 250 (assuming 8-bit) → 11111010
cout << (a << 1) << endl; // 10 → 00001010 (5 * 2)
cout << (a >> 1) << endl; // 2 → 00000010 (5 / 2)

Common use cases and techniques

1. Checking if a number is odd or even

Use the AND operator with 1 to check the least significant bit (LSB).

if (n & 1) {
    cout << "Odd" << endl;
} else {
    cout << "Even" << endl;
}

2. Toggling a specific bit

Use XOR to flip a bit at a given position.

n ^= (1 << k);  // Toggles the k-th bit (0-indexed)

3. Setting or clearing a bit

• Set the k-th bit: n |= (1 << k)
• Clear the k-th bit: n &= ~(1 << k)

This is useful in flags or configuration registers.

4. Extracting a bit

Check if the k-th bit is set:

bool isSet = (n >> k) & 1;

5. Swapping two numbers without extra space

Though not always recommended due to readability, XOR can swap values:

a ^= b;
b ^= a;
a ^= b;

Or more concisely:

a ^= b ^= a ^= b;  // Be cautious with side effects and sequence points

6. Counting set bits (population count)

Manually loop through bits:

int count = 0;
while (n) {
    count += n & 1;
    n >>= 1;
}

Or use built-in functions like __builtin_popcount(n) in GCC.

Important considerations

• Signed vs unsigned: Right shifting signed negative numbers is implementation-defined (usually arithmetic shift). Use unsigned types for predictable behavior.
• Integer promotion: Smaller types (like char, short) are promoted to int during operations. Be aware of sign extension.
• Operator precedence: Bitwise operators have lower precedence than comparison and arithmetic operators. Use parentheses to avoid bugs.

  if ((flags & MASK) == VALUE)  // Correct
  if (flags & MASK == VALUE)    // Wrong! == has higher precedence

• Avoid undefined behavior: Shifting by negative counts or by more than the bit width is undefined.

  x << n;  // Undefined if n < 0 or n >= bit-width of x

Practical example: Managing flags

Bitwise operators are great for managing multiple boolean options in a single variable.

const int READ = 1 << 0;    // 1
const int WRITE = 1 << 1;   // 2
const int EXECUTE = 1 << 2; // 4

int permissions = 0;
permissions |= READ | WRITE;        // Grant read and write
if (permissions & EXECUTE) {        // Check execute
    cout << "Executable" << endl;
}
permissions &= ~WRITE;              // Remove write

This pattern is widely used in system programming and APIs.

Basically, bitwise operators give you fine control over data at the bit level. They’re fast, efficient, and once you get used to binary thinking, quite intuitive. Just remember to use parentheses, prefer unsigned types, and document your bit logic clearly.

The above is the detailed content of How to work with bitwise operators in C. For more information, please follow other related articles on the PHP Chinese website!