Signed vs unsigned behavior on 8-bit MCU in Embedded C - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of signed and unsigned addition on 8-bit MCU

What is the output of this code snippet running on an 8-bit microcontroller where char is 8 bits?

Embedded C

#include <stdio.h>

int main() {
    unsigned char a = 250;
    signed char b = 10;
    unsigned char c = a + b;
    printf("%u\n", c);
    return 0;
}

A 4

B 250

C 10

D 260

💡 Hint

Remember that unsigned char wraps around at 255.

Adding 250 + 10 = 260. Since unsigned char can only hold 0-255, it wraps around modulo 256. 260 - 256 = 4.

❓ Predict Output

intermediate

Signed overflow behavior on 8-bit MCU

What is the output of this code snippet on an 8-bit MCU where char is signed 8-bit?

Embedded C

#include <stdio.h>

int main() {
    signed char x = 127;
    signed char y = 1;
    signed char z = x + y;
    printf("%d\n", z);
    return 0;
}

A 127

B 128

C 0

D -128

💡 Hint

Think about signed overflow and two's complement wrap-around.

Adding 127 + 1 causes signed overflow. On 8-bit signed char, max is 127, so it wraps to -128.

🔧 Debug

advanced

Why does this unsigned subtraction produce a large number?

Consider this code on an 8-bit MCU:

#include <stdio.h>

int main() {
    unsigned char a = 5;
    unsigned char b = 10;
    unsigned char c = a - b;
    printf("%u\n", c);
    return 0;
}

Why does it print 251 instead of a negative number?

A Because the compiler converts unsigned to signed before subtraction

B Because the printf format specifier is wrong and prints garbage

C Because unsigned subtraction wraps around modulo 256, so 5 - 10 = 251

D Because the MCU does not support subtraction on unsigned types

💡 Hint

Think about how unsigned arithmetic works on small fixed-size types.

Unsigned arithmetic wraps modulo 256 on 8-bit types. So 5 - 10 = -5 mod 256 = 251.

❓ Predict Output

advanced

Result of mixed signed and unsigned comparison

What is the output of this code on an 8-bit MCU?

Embedded C

#include <stdio.h>

int main() {
    signed char a = -1;
    unsigned char b = 255;
    if (a == b) {
        printf("Equal\n");
    } else {
        printf("Not Equal\n");
    }
    return 0;
}

A Not Equal

B Equal

C Compilation error

D Undefined behavior

💡 Hint

Integer promotions: both char types promote to signed int. -1 != 255.

Both operands undergo integer promotions to int: signed char -1 becomes int -1 (sign-extended), unsigned char 255 becomes int 255. Since -1 != 255, it prints "Not Equal".

🧠 Conceptual

expert

Why is signed integer overflow undefined but unsigned overflow well-defined?

On an 8-bit MCU, why does C define signed integer overflow as undefined behavior, but unsigned integer overflow wraps around modulo 256?

A Because the compiler automatically converts signed overflow to unsigned overflow internally

B Because unsigned overflow is defined by the C standard to wrap modulo 2^n, but signed overflow can cause unpredictable hardware states and is left undefined for optimization

C Because signed integers use two's complement and unsigned integers use sign-magnitude representation

D Because unsigned integers are stored differently in memory than signed integers

💡 Hint

Think about the C language standard and hardware behavior.

The C standard defines unsigned overflow as modulo arithmetic to allow predictable wrap-around. Signed overflow is undefined to allow compilers to optimize and because hardware behavior can vary.

Practice

1. What is the range of values for an 8-bit signed char on a typical MCU?

easy

A. -128 to 127

B. 0 to 255

C. -256 to 255

D. -127 to 128

Solution

1. Step 1: Understand 8-bit signed char range

   An 8-bit signed char uses one bit for sign and 7 bits for value, so it can represent values from -128 to 127.

2. Step 2: Compare with options

   Only -128 to 127 matches the correct range for signed 8-bit char.

3. Final Answer:

   -128 to 127 -> Option A

4. Quick Check:

   Signed 8-bit char range = -128 to 127 [OK]

Hint: Signed 8-bit char always includes negative half [OK]

Common Mistakes:

• Confusing signed and unsigned ranges
• Assuming 8-bit signed char goes to 255
• Mixing up sign bit usage

2. Which of the following declarations correctly defines an unsigned 8-bit variable in embedded C?

easy

A. signed char var;

B. int8_t var;

C. char unsigned var;

D. unsigned char var;

Solution

1. Step 1: Identify unsigned 8-bit type syntax

   In embedded C, unsigned char is the standard way to declare an unsigned 8-bit variable.

2. Step 2: Check other options

   signed char var; is signed, char unsigned var; is invalid syntax, int8_t var; is signed 8-bit integer.

3. Final Answer:

   unsigned char var; -> Option D

4. Quick Check:

   Unsigned 8-bit variable = unsigned char [OK]

Hint: Use 'unsigned char' for unsigned 8-bit variables [OK]

Common Mistakes:

• Using 'char unsigned' which is invalid syntax
• Assuming 'int8_t' is unsigned
• Confusing signed and unsigned keywords

3. Consider this code snippet on an 8-bit MCU:

unsigned char a = 250;
signed char b = (signed char)a;
printf("%d", b);

What is the output?

medium

A. 250

B. -6

C. 6

D. -250

Solution

1. Step 1: Understand casting from unsigned to signed

   Variable a holds 250 (unsigned). Casting to signed char wraps around because signed char max is 127.

2. Step 2: Calculate signed char value

   250 - 256 = -6 (wrap-around in 8-bit signed range)

3. Final Answer:

   -6 -> Option B

4. Quick Check:

   Unsigned 250 cast to signed 8-bit = -6 [OK]

Hint: Subtract 256 if unsigned > 127 when casting to signed [OK]

Common Mistakes:

• Assuming cast keeps original unsigned value
• Confusing sign extension with wrap-around
• Ignoring 8-bit overflow behavior

4. This code runs on an 8-bit MCU:

unsigned char x = 200;
signed char y = -100;
unsigned char z = x + y;
printf("%u", z);

What is the output?

medium

A. 156

B. 44

C. 100

D. 300

Solution

1. Step 1: Understand integer promotion in addition

   In expressions, unsigned char and signed char are promoted to int before addition.

2. Step 2: Calculate the sum

   200 + (-100) = 100 as int, but when assigned to unsigned char (8-bit), it wraps modulo 256. Since 100 fits in 8 bits, the value is 100.

3. Step 3: Print the result

   printf with %u prints unsigned int, so output is 100.

4. Final Answer:

   100 -> Option C

5. Quick Check:

   Signed promoted to int before addition, result 100 [OK]

Hint: Signed promoted to int before addition, watch final cast [OK]

Common Mistakes:

• Adding raw unsigned and signed bytes without promotion
• Assuming overflow without checking promotion
• Misinterpreting printf format specifiers

5. On an 8-bit MCU, you want to store the result of subtracting 150 from 100 using unsigned 8-bit variables:

unsigned char a = 100;
unsigned char b = 150;
unsigned char c = a - b;
printf("%u", c);

What will be printed and why?

hard

A. 206 because unsigned subtraction wraps around modulo 256

B. -50 because subtraction keeps sign in unsigned

C. 50 because it calculates absolute difference

D. Error due to negative result in unsigned

Solution

1. Step 1: Understand unsigned subtraction wrap-around

   Unsigned 8-bit subtraction wraps modulo 256. 100 - 150 = -50, which wraps to 256 - 50 = 206.

2. Step 2: Confirm printf output

   Variable c holds 206, so printf with %u prints 206.

3. Final Answer:

   206 because unsigned subtraction wraps around modulo 256 -> Option A

4. Quick Check:

   Unsigned subtraction wraps modulo 256 = 206 [OK]

Hint: Unsigned subtraction wraps modulo 256 on 8-bit MCU [OK]

Common Mistakes:

• Expecting negative numbers in unsigned arithmetic
• Assuming error on negative result
• Thinking subtraction gives absolute difference