Bitwise operators in Rust - Step-by-Step Execution

Concept Flow - Bitwise operators

Start with two numbers

↓

Apply bitwise operator (&, |, ^, <<, >>)

↓

Operate on each bit position

↓

Combine bits to form result

↓

Output the result

Bitwise operators work on each bit of two numbers, combining them to produce a new number.

Execution Sample

Rust

let a = 6;  // 0b0110
let b = 3;  // 0b0011
let c = a & b;
println!("{}", c);

This code performs a bitwise AND on 6 and 3, then prints the result.

Execution Table

Step	Operation	Bits of a	Bits of b	Bitwise & Result	Decimal Result
1	Start	0110	0011	-	-
2	Bit 3 (leftmost): 0 & 0	0	0	0	0
3	Bit 2: 1 & 0	1	0	0	0
4	Bit 1: 1 & 1	1	1	1	1
5	Bit 0 (rightmost): 0 & 1	0	1	0	0
6	Combine bits: 0010	-	-	0010	2
7	Print result	-	-	-	2

💡 All bits processed, final result is 2

Variable Tracker

Variable	Start	After & operation	Final
a	6 (0b0110)	6 (0b0110)	6 (0b0110)
b	3 (0b0011)	3 (0b0011)	3 (0b0011)
c	-	2 (0b0010)	2 (0b0010)

Key Moments - 3 Insights

Why does bit 2 result in 0 even though a has 1 there?

Because bitwise AND requires both bits to be 1. Here, b's bit 2 is 0, so 1 & 0 = 0 (see execution_table row 3).

Why is the final decimal result 2?

The combined bits after AND are 0010, which equals 2 in decimal (see execution_table row 6).

What happens if we use bitwise OR instead of AND?

Bits where either a or b is 1 become 1. The result would be 0111 (decimal 7), different from AND (see concept_flow).

Visual Quiz - 3 Questions

Look at the execution_table, what is the bitwise AND result at bit 1 (step 4)?

A 2

B 0

C 1

D 3

💡 Hint

Check execution_table row 4 under 'Bitwise & Result'

At which step does the combined bits form the final result?

A Step 6

B Step 5

C Step 7

D Step 3

💡 Hint

Look for 'Combine bits' in execution_table

If variable b was 7 (0b0111) instead of 3, what would be the decimal result after AND?

A 7

B 6

C 3

D 2

💡 Hint

AND with 6 (0110) and 7 (0111) keeps bits where both are 1

Concept Snapshot

Bitwise operators work on bits of numbers.
& (AND): 1 if both bits 1.
| (OR): 1 if either bit 1.
^ (XOR): 1 if bits differ.
<<, >> shift bits left/right.
Used for fast, low-level operations.

Full Transcript

This lesson shows how bitwise operators work in Rust. We start with two numbers, 6 and 3, and apply the bitwise AND operator. Each bit of the numbers is compared: only bits where both are 1 become 1 in the result. We trace each bit step-by-step, showing how the final result 2 is formed. Key points include understanding how bits combine and why the result is what it is. The quiz tests understanding of bitwise AND at specific bits and how changing inputs affects results.

Practice

1. Which bitwise operator in Rust returns 1 only if both bits are 1?
Example: 5 & 3

easy

A. AND (&)

B. OR (|)

C. XOR (^)

D. NOT (!)

Solution

1. Step 1: Understand the AND operator

   The AND operator (&) compares each bit of two numbers and returns 1 only if both bits are 1.

2. Step 2: Compare with other operators

   OR (|) returns 1 if either bit is 1, XOR (^) returns 1 if bits differ, NOT (!) flips bits.

3. Final Answer:

   AND (&) -> Option A

4. Quick Check:

   AND returns 1 only if both bits are 1 [OK]

Hint: AND is the only operator needing both bits as 1 [OK]

Common Mistakes:

• Confusing AND with OR which returns 1 if either bit is 1
• Thinking XOR returns 1 if both bits are 1
• Using NOT (!) as a binary operator instead of unary

2. Which of the following is the correct syntax for a bitwise XOR operation in Rust between variables a and b?

easy

A. a ! b

B. a & b

C. a | b

D. a ^ b

Solution

1. Step 1: Recall XOR operator symbol

   In Rust, the bitwise XOR operator is represented by the caret symbol (^).

2. Step 2: Check other operators

   & is AND, | is OR, and ! is unary NOT, so only a ^ b is correct for XOR.

3. Final Answer:

   a ^ b -> Option D

4. Quick Check:

   XOR uses ^ symbol in Rust [OK]

Hint: XOR uses ^ symbol, not & or | [OK]

Common Mistakes:

• Using & or | instead of ^ for XOR
• Trying to use ! as a binary operator
• Confusing syntax with other languages

3. What is the output of this Rust code?

let x = 0b1010;  // binary 10
let y = 0b1100;  // binary 12
let result = x | y;
println!("{:04b}", result);

medium

A. 1000

B. 1110

C. 0110

D. 1010

Solution

1. Step 1: Convert binary to bits and apply OR

   x = 1010, y = 1100. OR (|) returns 1 if either bit is 1. 1010 | 1100 = 1110

2. Step 2: Print result in 4-bit binary

   Result is 1110 in binary, which matches 1110.

3. Final Answer:

   1110 -> Option B

4. Quick Check:

   Bitwise OR of 1010 and 1100 = 1110 [OK]

Hint: OR sets bits where either input bit is 1 [OK]

Common Mistakes:

• Mixing up OR with AND results
• Reading binary digits incorrectly
• Forgetting to print in binary format

4. Identify the error in this Rust code snippet:

let a = 0b1010;
let b = 0b0101;
let c = a && b;
println!("{}", c);

medium

A. Incorrect binary literal syntax

B. Missing semicolon after let b

C. Using && instead of & for bitwise AND

D. println! macro missing format specifier

Solution

1. Step 1: Check operator usage

   The code uses && which is a logical AND, not bitwise AND. Bitwise AND uses &.

2. Step 2: Verify other syntax

   Semicolons are present, binary literals are correct, and println! has a format specifier, so no errors there.

3. Final Answer:

   Using && instead of & for bitwise AND -> Option C

4. Quick Check:

   Bitwise AND uses & not && [OK]

Hint: Use & for bitwise AND, && is logical AND [OK]

Common Mistakes:

• Confusing logical AND (&&) with bitwise AND (&)
• Assuming binary literals need prefix changes
• Missing format specifier in println! macro

5. Given a number n, which Rust expression flips (toggles) the 3rd bit (counting from 0) of n using bitwise operators?

hard

A. n ^ (1 << 3)

B. n & (1 << 3)

C. n | (1 << 3)

D. ~n & (1 << 3)

Solution

1. Step 1: Understand bit flipping with XOR

   XOR (^) with 1 flips the bit: if bit is 0 it becomes 1, if 1 it becomes 0. Shifting 1 by 3 sets the mask for the 3rd bit.

2. Step 2: Analyze other options

   & with mask clears bits except the 3rd bit, | sets the 3rd bit to 1, ~n & mask is unrelated to flipping a single bit.

3. Final Answer:

   n ^ (1 << 3) -> Option A

4. Quick Check:

   XOR with bit mask flips that bit [OK]

Hint: XOR with 1 at bit position flips that bit [OK]

Common Mistakes:

• Using & or | which clear or set bits instead of flipping
• Confusing ~ (NOT) usage
• Not shifting 1 to correct bit position