Bitwise '&' operator

Learn bitwise '&' operator with practical examples, diagrams, and best practices. Covers c, bitwise-operators development techniques with visual explanations.
Tags:
Categories:

Understanding the Bitwise AND (&) Operator in C

Hero image for Bitwise '&' operator

Explore the fundamental bitwise AND operator in C, its applications, and how it manipulates individual bits within integer types.

The bitwise AND operator (&) is a fundamental concept in low-level programming, particularly in languages like C. Unlike the logical AND (&&) which operates on boolean values, the bitwise AND operates directly on the individual bits of its operands. It compares corresponding bits of two integer values and returns a new integer where a bit is set to 1 only if both corresponding bits in the original operands were 1. Otherwise, the bit is set to 0. This operator is crucial for tasks such as masking, checking specific bits, and packing/unpacking data.

How the Bitwise AND Operator Works

At its core, the bitwise AND operator performs a logical AND operation on each pair of corresponding bits. Let's consider two numbers, A and B. For each bit position, if the bit in A is 1 AND the bit in B is 1, then the resulting bit in that position will be 1. In all other cases (0 AND 0, 0 AND 1, 1 AND 0), the resulting bit will be 0. This operation is performed independently for each bit position across the entire width of the integer type.

flowchart LR
    subgraph Bitwise AND Operation
        A[Bit A] --> C{AND}
        B[Bit B] --> C
        C --> D[Result Bit]
    end
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#f9f,stroke:#333,stroke-width:2px
    style C fill:#ccf,stroke:#333,stroke-width:2px
    style D fill:#afa,stroke:#333,stroke-width:2px

Conceptual flow of the bitwise AND operation on a single bit pair.

```c
#include <stdio.h>

int main() {
    unsigned char a = 5;  // Binary: 00000101
    unsigned char b = 3;  // Binary: 00000011
    unsigned char result;

    result = a & b;       // Binary: 00000001 (Decimal: 1)

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

    return 0;
}


*Example of the bitwise AND operator in C.*

In the example above:
- `a` is `5`, which is `00000101` in binary.
- `b` is `3`, which is `00000011` in binary.
- When `a & b` is performed, only the least significant bit (rightmost) is 1 in both `a` and `b`. All other corresponding bits have at least one 0, resulting in 0.
- Therefore, the result is `00000001`, which is `1` in decimal.

## Common Applications of Bitwise AND

The bitwise AND operator is incredibly versatile and finds numerous applications in system programming, embedded systems, and performance-critical code. Here are some of its most common uses:





## 1. Masking Bits

Masking is the process of selectively clearing or isolating specific bits within a number. By performing a bitwise AND with a 'mask' value, you can effectively filter out unwanted bits or extract desired ones. A mask is typically a number with 1s at the positions of the bits you want to keep/check and 0s elsewhere.

```c
```c
#include <stdio.h>

int main() {
    unsigned char data = 0b10110110; // Example data
    unsigned char mask = 0b00001111; // Mask to get the lower 4 bits
    unsigned char result;

    result = data & mask; // Extracts the lower 4 bits

    printf("Original data: 0x%02X (binary: %s)\n", data, "10110110");
    printf("Mask:          0x%02X (binary: %s)\n", mask, "00001111");
    printf("Result:        0x%02X (binary: %s)\n", result, "00000110"); // 0b00000110 is 6

    // Another example: checking if a specific bit is set
    unsigned char flag_register = 0b01010010; // Example register
    unsigned char check_bit_3 = 0b00001000; // Mask for 4th bit (0-indexed)

    if ((flag_register & check_bit_3) != 0) {
        printf("\nBit 3 is set in flag_register.\n");
    } else {
        printf("\nBit 3 is not set in flag_register.\n");
    }

    return 0;
}


*Using bitwise AND for masking and checking a specific bit.*

## 2. Checking Even or Odd Numbers

A common trick using the bitwise AND operator is to quickly determine if an integer is even or odd. An even number always has its least significant bit (LSB) as 0, while an odd number always has its LSB as 1. By ANDing a number with `1` (which is `0...0001` in binary), you can isolate the LSB. If the result is `1`, the number is odd; if the result is `0`, the number is even.

```c
```c
#include <stdio.h>

int main() {
    int num1 = 10; // Binary: ...01010
    int num2 = 7;  // Binary: ...00111

    if ((num1 & 1) == 0) {
        printf("%d is an even number.\n", num1);
    }

    if ((num2 & 1) != 0) {
        printf("%d is an odd number.\n", num2);
    }

    return 0;
}


*Checking for even or odd numbers using bitwise AND.*

## 3. Clearing Specific Bits

To clear (set to 0) specific bits in a number while leaving others unchanged, you can use a combination of the bitwise NOT (`~`) and bitwise AND (`&`) operators. First, create a mask with 1s at the positions you want to keep and 0s at the positions you want to clear. Then, apply the bitwise NOT to this mask to invert it (0s become 1s, 1s become 0s). Finally, perform a bitwise AND with the original number and the inverted mask.

```mermaid
flowchart TD
    A[Original Value] --> B{AND}
    C[Bits to Clear Mask] --> D[NOT]
    D --> B
    B --> E[Result (Bits Cleared)]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style C fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#ccf,stroke:#333,stroke-width:2px
    style E fill:#afa,stroke:#333,stroke-width:2px

Process for clearing specific bits using bitwise AND and NOT.

```c
#include <stdio.h>

int main() {
    unsigned char value = 0b11011010; // Original value
    unsigned char clear_mask = 0b00001100; // Mask to clear bits 2 and 3
    unsigned char result;

    // Invert the mask: ~00001100 becomes 11110011
    // Then AND with original value: 11011010 & 11110011 = 11010010
    result = value & (~clear_mask);

    printf("Original value: 0x%02X (binary: %s)\n", value, "11011010");
    printf("Clear mask:     0x%02X (binary: %s)\n", clear_mask, "00001100");
    printf("Result:         0x%02X (binary: %s)\n", result, "11010010");

    return 0;
}


*Clearing bits using bitwise AND with an inverted mask.*