Rust Bitwise Operators

Bitwise operators in Rust are used to perform operations directly on the binary representations of integers. These operators are essential for low-level programming, bit manipulation, and efficient computation tasks

Types of Bitwise Operators in Rust

Operator	Name	Description	Example	Binary Example	Output
&	Bitwise AND	Sets a bit to 1 if both bits are 1.	5 & 3	0101 & 0011	0001 (1)
`	`	Bitwise OR	Sets a bit to 1 if at least one bit is 1.	`5	3`
^	Bitwise XOR	Sets a bit to 1 if the bits are different.	5 ^ 3	0101 ^ 0011	0110 (6)
!	Bitwise NOT	Inverts all the bits (1 becomes 0, and 0 becomes 1).	!5	!0101	1010 (-6)
<<	Left Shift	Shifts bits to the left by the specified count.	5 << 1	0101 << 1	1010 (10)
>>	Right Shift	Shifts bits to the right by the specified count.	5 >> 1	0101 >> 1	0010 (2)

Detailed Explanation of Each Operator

1. Bitwise AND (&)

This operator compares each bit of two numbers and sets the result to 1 if both bits are 1.

Syntax:

let result = value1 & value2;

Example:

fn main() {
    let a = 5; // Binary: 0101
    let b = 3; // Binary: 0011
    println!("Bitwise AND: {}", a & b); // Output: 1
}

2. Bitwise OR ( | )

This operator compares each bit of two numbers and sets the result to 1 if at least one of the bits is 1.

Syntax:

let result = value1 | value2;

Example:

fn main() {
    let a = 5; // Binary: 0101
    let b = 3; // Binary: 0011
    println!("Bitwise OR: {}", a | b); // Output: 7
}

3. Bitwise XOR (^)

This operator compares each bit of two numbers and sets the result to 1 if the bits are different.

Syntax:

let result = value1 ^ value2;

Example:

fn main() {
    let a = 5; // Binary: 0101
    let b = 3; // Binary: 0011
    println!("Bitwise XOR: {}", a ^ b); // Output: 6
}

4. Bitwise NOT ( ! )

This operator inverts all bits of a number. In Rust, integers are stored as signed values, so the result includes the two’s complement representation.

Syntax:

let result = !value;

Example:

fn main() {
    let a = 5; // Binary: 0101
    println!("Bitwise NOT: {}", !a); // Output: -6
}

5. Left Shift (<<)

This operator shifts bits to the left by a specified number of positions, filling with zeros from the right. Each shift to the left effectively multiplies the number by 2.

Syntax:

let result = value << positions;

Example:

fn main() {
    let a = 5; // Binary: 0101
    println!("Left Shift: {}", a << 1); // Output: 10
}

6. Right Shift (>>)

This operator shifts bits to the right by a specified number of positions, filling with zeros from the left. Each shift to the right effectively divides the number by 2.

Syntax:

let result = value >> positions;

Example:

fn main() {
    let a = 5; // Binary: 0101
    println!("Right Shift: {}", a >> 1); // Output: 2
}

Practical Application: Using Bitwise Operators

Example: Using Bitwise AND to Check Even or Odd Numbers

fn main() {
    let number = 4; // Binary: 0100
    if number & 1 == 0 {
        println!("The number is even.");
    } else {
        println!("The number is odd.");
    }
}

Output:

The number is even.

Example: Using Bitwise OR to Set Specific Bits

fn main() {
    let flags = 0b0010; // Initial flags
    let mask = 0b1000; // Mask to set a specific bit
    let new_flags = flags | mask;
    println!("Updated Flags: {:b}", new_flags); // Output: 1010
}

Key Points to Remember

1. Binary Representation:
   Bitwise operators operate directly on binary data. Always visualize the binary representation of numbers to understand the operations better.
2. Efficiency:
   Bitwise operations are faster than arithmetic operations and are often used in performance-critical applications.
3. Error Prevention:
   Use parentheses to make expressions clearer and avoid unexpected results due to operator precedence.