Set Clear Toggle a Specific Bit in DSA C++ - Build from Scratch

Set, Clear, and Toggle a Specific Bit

📖 Scenario: Imagine you are working with a simple device that uses an 8-bit control register to manage its settings. Each bit in this register controls a different feature. You need to learn how to change these bits to turn features on or off or flip their current state.

🎯 Goal: You will create a program that can set, clear, and toggle a specific bit in an 8-bit number. This will help you understand how to manipulate bits directly, which is useful in low-level programming and hardware control.

📋 What You'll Learn

Create an 8-bit unsigned integer variable called control_register with the value 0b00001100.

Create an integer variable called bit_position and set it to 2.

Write code to set the bit at bit_position in control_register.

Write code to clear the bit at bit_position in control_register.

Write code to toggle the bit at bit_position in control_register.

Print the binary value of control_register after each operation.

💡 Why This Matters

🌍 Real World

Bit manipulation is used in embedded systems, device drivers, and performance-critical applications where direct control over hardware or memory is needed.

💼 Career

Understanding bitwise operations is essential for roles in embedded programming, systems programming, and any job that involves low-level hardware interaction.

1

Create the initial control register

Create an 8-bit unsigned integer variable called control_register and set it to the binary value 0b00001100.

DSA C++

# Create the control_register variable with value 0b00001100
# Your code here

Hint

Use unsigned char to create an 8-bit variable and assign the binary value 0b00001100.

2

Set the bit position

Create an integer variable called bit_position and set it to 2.

DSA C++

unsigned char control_register = 0b00001100;
// Create bit_position variable and set it to 2
// Your code here

Hint

Use int to create the variable bit_position and assign it the value 2.

3

Set, clear, and toggle the bit

Write code to set the bit at bit_position in control_register, then clear the bit at bit_position, and finally toggle the bit at bit_position. Use the bitwise operators |=, &= ~, and ^= respectively.

DSA C++

unsigned char control_register = 0b00001100;
int bit_position = 2;

// Set the bit at bit_position
// Your code here

// Clear the bit at bit_position
// Your code here

// Toggle the bit at bit_position
// Your code here

Hint

Use 1 << bit_position to create a mask for the bit. Use |= to set, &= ~ to clear, and ^= to toggle the bit.

4

Print the control register after each operation

Print the binary value of control_register after setting, clearing, and toggling the bit. Use std::bitset<8> to display the 8-bit binary format.

DSA C++

#include 
#include 

unsigned char control_register = 0b00001100;
int bit_position = 2;

// Set the bit at bit_position
control_register |= (1 (control_register) (control_register) (control_register) << std::endl;

// Your code here

Hint

Use std::bitset<8>(control_register) to print the binary form of the 8-bit number after each operation.

Practice

1. What does the operation num |= (1 << k) do to the integer num in C++?

easy

A. Toggles the k-th bit of num

B. Sets the k-th bit of num to 1

C. Clears the k-th bit of num to 0

D. Checks if the k-th bit of num is set

Solution

1. Step 1: Understand the bit shift operation

   The expression 1 << k creates a number with only the k-th bit set to 1 and all others 0.

2. Step 2: Apply bitwise OR to set the bit

   Using |= with this mask sets the k-th bit of num to 1 without changing other bits.

3. Final Answer:

   Sets the k-th bit of num to 1 -> Option B

4. Quick Check:

   num |= (1 << k) sets bit k [OK]

Hint: Use OR with shifted 1 to set a bit [OK]

Common Mistakes:

• Confusing set with clear operation
• Using AND instead of OR to set bits
• Misunderstanding bit positions starting from 0

2. Which of the following is the correct syntax to clear the 3rd bit (0-indexed) of an integer variable num in C++?

easy

A. num &= ~(1 << 3);

B. num |= (1 << 3);

C. num ^= (1 << 3);

D. num = (num & (1 << 3));

Solution

1. Step 1: Create mask to clear bit

   1 << 3 sets only the 3rd bit. Negating it with ~ creates a mask with all bits 1 except the 3rd bit 0.

2. Step 2: Use AND assignment to clear bit

   Applying &= with this mask clears the 3rd bit of num while keeping others unchanged.

3. Final Answer:

   num &= ~(1 << 3); -> Option A

4. Quick Check:

   AND with negated mask clears bit [OK]

Hint: Use AND with negated shifted 1 to clear bit [OK]

Common Mistakes:

• Using OR instead of AND to clear bits
• Forgetting to negate the mask
• Using XOR which toggles instead of clears

3. What is the output of the following C++ code?

int num = 10; // binary 1010
num ^= (1 << 1);
std::cout << num << std::endl;

medium

A. 8

B. 10

C. 12

D. 14

Solution

1. Step 1: Understand initial value and bit positions

   num = 10 in binary is 1010. Bits are indexed from 0 (rightmost). Bit 1 is currently 1.

2. Step 2: Toggle the 1st bit using XOR

   num ^= (1 << 1) toggles bit 1. Since bit 1 is 1, toggling it changes it to 0. New binary: 1000 (decimal 8).

3. Final Answer:

   8 -> Option A

4. Quick Check:

   Toggle bit 1 of 1010 = 1000 = 8 [OK]

Hint: XOR toggles bits; 1 flips, 0 stays same [OK]

Common Mistakes:

• Confusing toggle with set or clear
• Miscounting bit positions starting at 1 instead of 0
• Assuming XOR always sets bit

4. Identify the error in the following code snippet that attempts to clear the 2nd bit of num:

int num = 15;
num = num & (1 << 2);
std::cout << num << std::endl;

medium

A. It sets only the 2nd bit instead of clearing it

B. It toggles the 2nd bit instead of clearing it

C. It clears all bits except the 2nd bit

D. It causes a syntax error due to missing parentheses

Solution

1. Step 1: Analyze the mask used

   The mask (1 << 2) has only the 2nd bit set to 1, all others 0.

2. Step 2: Understand the effect of AND with mask

   ANDing num with this mask keeps only the 2nd bit of num and clears all others. This is opposite of clearing the 2nd bit.

3. Final Answer:

   It clears all bits except the 2nd bit -> Option C

4. Quick Check:

   AND with mask keeps bit, does not clear it [OK]

Hint: Use AND with negated mask to clear bits, not plain mask [OK]

Common Mistakes:

• Using mask directly instead of negated mask
• Confusing AND with OR for clearing bits
• Assuming AND with mask clears bit

5. Given an integer num, which expression correctly toggles the 0th bit only if it is currently set (1), otherwise leaves num unchanged?

hard

A. num ^= 1;

B. num &= ~1;

C. num |= 1;

D. if ((num & 1) == 1) num ^= 1;

Solution

1. Step 1: Check if 0th bit is set

   The condition (num & 1) == 1 checks if the least significant bit is 1.

2. Step 2: Toggle 0th bit only if set

   If the bit is set, num ^= 1 toggles it to 0. Otherwise, no change is made.

3. Final Answer:

   if ((num & 1) == 1) num ^= 1; -> Option D

4. Quick Check:

   Toggle only if bit set using condition [OK]

Hint: Check bit before toggling to avoid unwanted changes [OK]

Common Mistakes:

• Toggling bit unconditionally
• Using OR or AND which always set or clear bit
• Not checking bit state before toggle