Left shift and right shift behavior in Embedded C - Mini Project: Build & Apply

Left shift and right shift behavior

📖 Scenario: You are working with an embedded system that controls lights using bit patterns. You need to understand how shifting bits left and right changes the pattern.

🎯 Goal: Learn how to use left shift (<<) and right shift (>>) operators in C to manipulate bits in an integer.

📋 What You'll Learn

Create an unsigned integer variable called pattern with the value 0x01 (hexadecimal 1).

Create an integer variable called shift_amount and set it to 3.

Use left shift operator to shift pattern by shift_amount and store the result in left_shifted.

Use right shift operator to shift pattern by shift_amount and store the result in right_shifted.

Print the values of left_shifted and right_shifted in hexadecimal format.

💡 Why This Matters

🌍 Real World

Bit shifting is used in embedded systems to control hardware, set flags, and optimize performance.

💼 Career

Understanding bit manipulation is important for embedded software developers, firmware engineers, and anyone working close to hardware.

1

Create the initial variable pattern

Create an unsigned integer variable called pattern and set it to 0x01.

Embedded C

# Create an unsigned int variable called pattern and set it to 0x01
# Your code here

Hint

Use unsigned int pattern = 0x01; to create the variable.

2

Create the variable shift_amount

Create an integer variable called shift_amount and set it to 3.

Embedded C

unsigned int pattern = 0x01;
// Create an int variable called shift_amount and set it to 3
// Your code here

Hint

Use int shift_amount = 3; to create the variable.

3

Apply left and right shift operators

Create two unsigned integer variables called left_shifted and right_shifted. Use the left shift operator (<<) to shift pattern by shift_amount and store it in left_shifted. Use the right shift operator (>>) to shift pattern by shift_amount and store it in right_shifted.

Embedded C

unsigned int pattern = 0x01;
int shift_amount = 3;
// Create left_shifted and right_shifted variables with shifted values
// Your code here

Hint

Use left_shifted = pattern << shift_amount; and right_shifted = pattern >> shift_amount;.

4

Print the shifted values

Print the values of left_shifted and right_shifted in hexadecimal format using printf. Use the format specifier %#x to show the 0x prefix.

Embedded C

unsigned int pattern = 0x01;
int shift_amount = 3;
unsigned int left_shifted = pattern > shift_amount;
// Print left_shifted and right_shifted in hex format
// Your code here

Hint

Use printf("Left shifted: %#x\n", left_shifted); and printf("Right shifted: %#x\n", right_shifted);.

Practice

1. What does the left shift operator << do to an unsigned integer in embedded C?

easy

A. Divides the number by powers of two

B. Inverts all bits of the number

C. Multiplies the number by powers of two

D. Leaves the number unchanged

Solution

1. Step 1: Understand left shift operation

   The left shift operator moves bits to the left, adding zeros on the right.

2. Step 2: Effect on unsigned integer value

   Shifting left by 1 bit multiplies the number by 2, shifting by n bits multiplies by 2^n.

3. Final Answer:

   Multiplies the number by powers of two -> Option C

4. Quick Check:

   Left shift = multiply by 2^n [OK]

Hint: Left shift multiplies by 2 for each shift [OK]

Common Mistakes:

• Thinking left shift divides the number
• Confusing left shift with bitwise NOT
• Assuming left shift leaves number unchanged

2. Which of the following is the correct syntax to shift the integer variable x right by 3 bits in embedded C?

easy

A. x >>3

B. x << 3;

C. x >>> 3;

D. x >> 3;

Solution

1. Step 1: Identify right shift operator syntax

   In embedded C, right shift is done using >> operator with spaces optional.

2. Step 2: Check options for correct syntax

   The correct syntax is x >> 3; using the right shift operator >>, shift amount 3, and semicolon to form a valid statement. Lacking semicolon, using left shift <<, or invalid operator like >>> are incorrect.

3. Final Answer:

   x >> 3; -> Option D

4. Quick Check:

   Right shift syntax = x >> n; [OK]

Hint: Right shift uses >> operator with semicolon [OK]

Common Mistakes:

• Using >>> which is not valid in C
• Confusing left shift << with right shift >>
• Omitting semicolon at end

3. What is the output of the following code snippet?

unsigned int x = 4;
unsigned int y = x << 2;
printf("%u", y);

medium

A. 16

B. 8

C. 1

D. 32

Solution

1. Step 1: Understand initial value and shift

   Variable x is 4 (binary 100). Left shifting by 2 bits moves bits left twice.

2. Step 2: Calculate shifted value

   4 << 2 = 4 * 2^2 = 4 * 4 = 16.

3. Final Answer:

   16 -> Option A

4. Quick Check:

   4 << 2 = 16 [OK]

Hint: Left shift by n multiplies by 2^n [OK]

Common Mistakes:

• Confusing left shift with right shift
• Calculating 4 << 2 as 8 instead of 16
• Ignoring unsigned type behavior

4. Consider this code snippet:

int x = -16;
int y = x >> 2;
printf("%d", y);

What is the likely output assuming arithmetic right shift?

medium

A. -4

B. 4

C. -1

D. 0

Solution

1. Step 1: Understand signed right shift behavior

   For signed integers, right shift usually preserves the sign bit (arithmetic shift).

2. Step 2: Calculate shifted value

   -16 in binary (two's complement) is shifted right by 2 bits, dividing by 4 but keeping sign, so -16 >> 2 = -4.

3. Final Answer:

   -4 -> Option A

4. Quick Check:

   Signed right shift divides and keeps sign [OK]

Hint: Signed right shift divides and keeps sign bit [OK]

Common Mistakes:

• Assuming right shift always fills with zeros
• Confusing signed and unsigned shift results
• Expecting positive result from negative input

5. You want to multiply an unsigned 8-bit integer val by 8 using bit shifts without overflow. Which code snippet is correct?

unsigned char val = 20;
unsigned char result = val << 3;

What should you check before shifting to avoid overflow?

hard

A. Ensure val <= 8 before shifting

B. Ensure val <= 31 before shifting

C. Ensure val <= 20 before shifting

D. No check needed, shifting never overflows

Solution

1. Step 1: Understand shift and overflow risk

   Shifting left by 3 multiplies by 8. For 8-bit unsigned, max value is 255.

2. Step 2: Calculate max safe value

   To avoid overflow: val * 8 <= 255 -> val <= 31.875, so val must be ≤ 31.

3. Final Answer:

   Ensure val <= 31 before shifting -> Option B

4. Quick Check:

   Max val before shift = 255 / 8 = 31 [OK]

Hint: Check max value before shift to prevent overflow [OK]

Common Mistakes:

• Ignoring overflow risk on left shift
• Assuming shifting never causes overflow
• Using wrong max value for 8-bit unsigned