Bit field structures in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of bit field structure size and values

What is the output of this C code when compiled and run on a typical 32-bit system?

Embedded C

typedef struct {
    unsigned int a:3;
    unsigned int b:5;
    unsigned int c:6;
} Bits;

#include <stdio.h>
int main() {
    Bits x = {5, 17, 33};
    printf("Size: %zu\n", sizeof(x));
    printf("a=%u b=%u c=%u\n", x.a, x.b, x.c);
    return 0;
}

A

Size: 4
a=5 b=17 c=1

B

Size: 4
a=5 b=17 c=33

C

Size: 2
a=5 b=17 c=1

D

Size: 2
a=5 b=17 c=33

💡 Hint

Remember that bit fields pack bits tightly and the size depends on total bits used.

The struct has 3+5+6=14 bits total, which fits in 2 bytes. The values fit in their bit widths, so c=33 is stored correctly. Size is 2 bytes on typical systems.

🧠 Conceptual

intermediate

Bit field overflow behavior

Given this bit field declaration:
unsigned int x:3;
What happens if you assign x = 10; ?

A Compilation error due to overflow

B x stores the value 2 because only the lowest 3 bits are kept

C x stores the value 10 without any change

D x stores 0 because 10 is out of range

💡 Hint

Think about how many bits 3 bits can hold and what happens to extra bits.

A 3-bit unsigned field can hold values 0 to 7. Assigning 10 (binary 1010) keeps only the lowest 3 bits (010), which is 2.

🔧 Debug

advanced

Why does this bit field struct cause unexpected output?

Consider this code snippet:

typedef struct {
    unsigned int flag:1;
    unsigned int value:7;
} Data;

int main() {
    Data d = {1, 130};
    printf("flag=%u value=%u\n", d.flag, d.value);
    return 0;
}

What is the reason for the unexpected output of value?

A The struct is not properly aligned causing garbage values

B The flag bit overlaps with value causing corruption

C The value 130 exceeds 7 bits and wraps around, causing unexpected value

D The printf format specifier is incorrect for bit fields

💡 Hint

Check the maximum value storable in 7 bits and what happens if you assign a bigger number.

7 bits can store max 127. Assigning 130 causes overflow and wraps around to 2 (130 - 128). So value prints as 2, which is unexpected.

📝 Syntax

advanced

Identify the syntax error in bit field declaration

Which option contains a syntax error in bit field declaration?

A struct S { unsigned int a:4; unsigned int b;:5 };

B struct S { unsigned int a:4; unsigned int b:5; };

C struct S { unsigned int a:4; unsigned b:5; };

D struct S { unsigned int a:4; int b:5; };

💡 Hint

Look carefully at the colon placement in bit field syntax.

Option A has a misplaced colon after 'b;' which is invalid syntax. Bit field size must follow the variable name without extra semicolons.

🚀 Application

expert

Calculate total bits and size of nested bit field structs

Given these nested structs:

typedef struct {
    unsigned int x:4;
    unsigned int y:4;
} Inner;

typedef struct {
    Inner a;
    unsigned int z:8;
} Outer;

#include 
int main() {
    printf("Size of Outer: %zu\n", sizeof(Outer));
    return 0;
}

What is the output of the program?

A Size of Outer: 4

B Size of Outer: 3

C Size of Outer: 1

D Size of Outer: 2

💡 Hint

Calculate total bits in Inner and Outer and consider alignment and padding.

Inner has 4+4=8 bits (1 byte). Outer adds 8 bits (1 byte) for z, total 16 bits (2 bytes). But due to alignment on typical 32-bit systems, sizeof(Outer) is 4 bytes.

Practice

1. What is the main purpose of using bit field structures in embedded C?

easy

A. To improve floating-point calculations

B. To create large arrays of integers

C. To store multiple small data values efficiently using specific bits

D. To allocate memory dynamically

Solution

1. Step 1: Understand bit field structures

   Bit field structures allow storing data in a compact form by specifying the number of bits each field uses.

2. Step 2: Identify the main purpose

   This helps save memory by packing multiple small values into fewer bytes, useful for flags or hardware registers.

3. Final Answer:

   To store multiple small data values efficiently using specific bits -> Option C

4. Quick Check:

   Bit fields save memory by using bits = A [OK]

Hint: Bit fields pack small data into bits to save memory [OK]

Common Mistakes:

• Thinking bit fields create large arrays
• Confusing bit fields with floating-point optimization
• Assuming bit fields allocate memory dynamically

2. Which of the following is the correct syntax to declare a bit field of 3 bits named flags inside a struct?

easy

A. unsigned int flags(3);

B. unsigned int flags = 3;

C. unsigned int : flags 3;

D. unsigned int flags : 3;

Solution

1. Step 1: Recall bit field syntax

   Bit fields use a colon after the variable name to specify the number of bits, e.g., flags : 3.

2. Step 2: Check each option

   unsigned int flags : 3; correctly uses unsigned int flags : 3;. Others have invalid syntax.

3. Final Answer:

   unsigned int flags : 3; -> Option D

4. Quick Check:

   Bit field syntax uses colon = D [OK]

Hint: Bit field size follows colon after variable name [OK]

Common Mistakes:

• Using equals sign instead of colon
• Placing size before variable name
• Using parentheses instead of colon

3. Given the struct definition:

struct S {
  unsigned int a : 2;
  unsigned int b : 3;
  unsigned int c : 3;
};

struct S s = {3, 5, 7};
printf("%u %u %u", s.a, s.b, s.c);

What is the output?

medium

A. 3 5 3

B. 3 5 7

C. 3 1 7

D. 3 5 0

Solution

1. Step 1: Understand bit field sizes and value limits

   Field a has 2 bits (max 3), b has 3 bits (max 7), c has 3 bits (max 7).

2. Step 2: Check assigned values and truncation

   Values assigned: a=3 (fits 2 bits), b=5 (fits 3 bits), c=7 (fits 3 bits). However, the value 7 assigned to c (3 bits) will be truncated if it exceeds the max value. Since 3 bits can hold max 7, 7 fits exactly, so no truncation. But the initializer list {3,5,7} assigns 7 to c, which is 3 bits wide. However, in practice, some compilers truncate values exceeding the bit field size modulo 2^n. Since 7 fits 3 bits, it should print 7. But the question's options suggest otherwise.

3. Step 3: Re-examine the options

   3 5 3 is "3 5 3", which suggests truncation of 7 to 3, which is incorrect. 3 5 7 is "3 5 7", which matches the expected output.

4. Final Answer:

   3 5 7 -> Option B

5. Quick Check:

   Bit fields store values truncated to their bit size; 7 fits 3 bits = 3 5 7 [OK]

Hint: Check max value for bits; values truncate if too big [OK]

Common Mistakes:

• Assuming 7 truncates to 3
• Ignoring bit size limits
• Confusing decimal and binary values

4. Identify the error in this bit field struct declaration:

struct Flags {
  unsigned int flag1 : 1;
  int flag2 : 2;
  unsigned flag3 : 3;
};

medium

A. No error; this is valid syntax

B. Missing bit size for flag3

C. Using signed int for bit field is not allowed

D. Mixing signed and unsigned bit fields causes error

Solution

1. Step 1: Check bit field type rules

   Bit fields can be signed or unsigned integers. Using int or unsigned int is allowed.

2. Step 2: Verify bit size for each field

   All fields specify bit sizes: flag1:1, flag2:2, flag3:3. The type unsigned is shorthand for unsigned int.

3. Final Answer:

   No error; this is valid syntax -> Option A

4. Quick Check:

   Signed and unsigned bit fields allowed = C [OK]

Hint: Signed or unsigned int bit fields both allowed [OK]

Common Mistakes:

• Assuming signed bit fields are invalid
• Thinking unsigned must be 'unsigned int'
• Missing bit size causes error, but here all sizes present

5. You want to store the status of 10 different flags (each 1 bit) and a 6-bit error code in a struct using bit fields. Which struct layout uses the least memory on a 32-bit system?

hard

A. struct { unsigned int flags : 10; unsigned int error : 6; };

B. struct { unsigned int flag1 : 1; unsigned int flag2 : 1; unsigned int flag3 : 1; unsigned int flag4 : 1; unsigned int flag5 : 1; unsigned int flag6 : 1; unsigned int flag7 : 1; unsigned int flag8 : 1; unsigned int flag9 : 1; unsigned int flag10 : 1; unsigned int error : 6; };

C. struct { unsigned char flags : 10; unsigned char error : 6; };

D. struct { unsigned short flags : 10; unsigned short error : 6; };

Solution

1. Step 1: Understand bit field packing

   Bit fields are packed into the base type size. Using one unsigned int for all bits packs them tightly.

2. Step 2: Compare options

   struct { unsigned int flags : 10; unsigned int error : 6; }; packs all 16 bits (10 flags + 6 error) into one unsigned int (32 bits). struct { unsigned int flag1 : 1; unsigned int flag2 : 1; unsigned int flag3 : 1; unsigned int flag4 : 1; unsigned int flag5 : 1; unsigned int flag6 : 1; unsigned int flag7 : 1; unsigned int flag8 : 1; unsigned int flag9 : 1; unsigned int flag10 : 1; unsigned int error : 6; }; declares each flag separately, but still packed into unsigned int, so similar size but more verbose. struct { unsigned char flags : 10; unsigned char error : 6; }; uses unsigned char (8 bits), but 10 bits can't fit in 8 bits, so likely uses more space due to alignment. struct { unsigned short flags : 10; unsigned short error : 6; }; uses unsigned short (16 bits), which fits 16 bits exactly, but alignment may cause padding.

3. Final Answer:

   struct { unsigned int flags : 10; unsigned int error : 6; }; -> Option A

4. Quick Check:

   Pack all bits in one unsigned int for minimal size = B [OK]

Hint: Group bits in one unsigned int to minimize memory [OK]

Common Mistakes:

• Using multiple small types causing padding
• Assuming unsigned char can hold 10 bits
• Declaring each flag separately wastes space