Fixed-width integers (uint8_t, uint16_t, uint32_t) in Embedded C

Introduction

Fixed-width integers let you store numbers using a set number of bits. This helps you control memory and avoid surprises when your program runs on different devices.

When you need to save memory by using the smallest number type that fits your data.

When you want your program to behave the same on different computers or microcontrollers.

When working with hardware registers that require exact bit sizes.

When sending data over a network or storing it in files where size matters.

When you want to avoid errors caused by integer size differences.

Syntax

Embedded C

#include <stdint.h>

uint8_t smallNumber;   // 8-bit unsigned integer
uint16_t mediumNumber; // 16-bit unsigned integer
uint32_t largeNumber;  // 32-bit unsigned integer

These types are defined in the stdint.h header.

They always have the same size on any platform, unlike int or long.

Examples

Here we declare three variables with different fixed sizes to store numbers of different ranges.

Embedded C

#include <stdint.h>

uint8_t age = 25;  // can store 0 to 255
uint16_t distance = 1000;  // can store 0 to 65535
uint32_t population = 1000000;  // can store 0 to 4,294,967,295

Using uint8_t is handy when you want to work with bits directly.

Embedded C

#include <stdint.h>

uint8_t flags = 0b00001111;  // 8 bits, useful for bit operations

Sample Program

This program shows how to declare and print fixed-width unsigned integers. It prints the values stored in each variable.

Embedded C

#include <stdio.h>
#include <stdint.h>

int main() {
    uint8_t small = 255;
    uint16_t medium = 50000;
    uint32_t large = 3000000000U;

    printf("small (uint8_t) = %u\n", small);
    printf("medium (uint16_t) = %u\n", medium);
    printf("large (uint32_t) = %u\n", large);

    return 0;
}

Important Notes

Unsigned types like uint8_t can only store zero or positive numbers.

Using fixed-width integers helps avoid bugs caused by different integer sizes on different machines.

Remember to include stdint.h to use these types.

Summary

Fixed-width integers store numbers using a fixed number of bits.

They help write portable and memory-efficient code.

Use uint8_t, uint16_t, and uint32_t for 8, 16, and 32-bit unsigned numbers.

Practice

1. What is the size in bits of the uint16_t type in embedded C?

easy

A. 64 bits

B. 8 bits

C. 32 bits

D. 16 bits

Solution

1. Step 1: Understand the meaning of uint16_t

   The suffix 16_t means it uses 16 bits to store the number.

2. Step 2: Confirm the size

   By definition, uint16_t is an unsigned integer type that uses exactly 16 bits.

3. Final Answer:

   16 bits -> Option D

4. Quick Check:

   uint16_t = 16 bits [OK]

Hint: Look at the number in the type name for bit size [OK]

Common Mistakes:

• Confusing uint16_t with uint8_t
• Thinking it stores 16 bytes instead of bits
• Mixing signed and unsigned types

2. Which of the following is the correct way to declare a 32-bit unsigned integer variable named count?

easy

A. int32_t count;

B. uint32_t count;

C. uint16_t count;

D. int count32;

Solution

1. Step 1: Identify the correct type for 32-bit unsigned integer

   uint32_t is the standard fixed-width unsigned 32-bit integer type.

2. Step 2: Check the variable declaration syntax

   The syntax uint32_t count; correctly declares the variable count with that type.

3. Final Answer:

   uint32_t count; -> Option B

4. Quick Check:

   32-bit unsigned integer declaration = uint32_t count; [OK]

Hint: Use uint32_t for 32-bit unsigned integers [OK]

Common Mistakes:

• Using signed type int32_t instead of unsigned
• Using wrong bit size like uint16_t
• Incorrect variable naming or syntax

3. What will be the output of this code snippet?

#include 
#include 

int main() {
    uint8_t a = 250;
    uint8_t b = 10;
    uint8_t c = a + b;
    printf("%u", c);
    return 0;
}

medium

A. 260

B. Overflow error

C. 4

D. 10

Solution

1. Step 1: Understand the variable types and values

   a and b are uint8_t, which can hold values 0-255. a=250, b=10.

2. Step 2: Calculate the sum and consider overflow

   Sum is 250 + 10 = 260. Since uint8_t max is 255, it wraps around modulo 256: 260 - 256 = 4.

3. Final Answer:

   4 -> Option C

4. Quick Check:

   260 mod 256 = 4 [OK]

Hint: Remember 8-bit max is 255; sums wrap around modulo 256 [OK]

Common Mistakes:

• Expecting 260 as output ignoring overflow
• Thinking it causes runtime error
• Confusing signed and unsigned overflow behavior

4. Identify the error in this code snippet:

#include 

uint8_t x = 300;

medium

A. 300 is too large for uint8_t and causes overflow

B. Missing semicolon after declaration

C. uint8_t cannot be used without stdint.h

D. Variable name x is invalid

Solution

1. Step 1: Check the value assigned to uint8_t

   uint8_t can only hold values 0 to 255. 300 is outside this range.

2. Step 2: Understand the effect of assigning 300

   Assigning 300 causes overflow and the stored value wraps modulo 256, resulting in 44 (300 - 256).

3. Final Answer:

   300 is too large for uint8_t and causes overflow -> Option A

4. Quick Check:

   Value 300 > max 255 for uint8_t [OK]

Hint: Check if assigned value fits in the type's bit size [OK]

Common Mistakes:

• Assuming compiler error instead of overflow
• Ignoring the max value limit of uint8_t
• Thinking variable name or syntax is wrong

5. You want to store the number 70000 in a fixed-width unsigned integer variable. Which type should you choose to avoid overflow?

hard

A. uint32_t

B. uint16_t

C. uint8_t

D. int16_t

Solution

1. Step 1: Check the value range of each type

   uint8_t max is 255, uint16_t max is 65535, uint32_t max is 4294967295, int16_t max is 32767.

2. Step 2: Find the type that can hold 70000

   70000 is greater than 65535 and 32767, so only uint32_t can hold it without overflow.

3. Final Answer:

   uint32_t -> Option A

4. Quick Check:

   70000 <= 4294967295 of uint32_t [OK]

Hint: Pick type with max value ≥ your number to avoid overflow [OK]

Common Mistakes:

• Choosing uint16_t which is too small
• Using signed types that have smaller max positive values
• Ignoring overflow limits