1. The sizeof Operator: Size in Bytes at Compile Time

sizeof is an operator, not a function. It yields the size in bytes of its operand as a value of type size_t (an unsigned integer type from <stddef.h>). The compiler evaluates it at compile time, so it costs nothing at run time and can be used in constant expressions such as array bounds and _Static_assert.

2. Implicit Type Conversion: Integer Promotion

Type casting in embedded C starts with the casts you never write: C converts values automatically in many situations. The first and most surprising rule is integer promotion: any operand of a type narrower than int (char, short, uint8_t, int16_t, bool) is converted to int (or to unsigned int if int cannot hold all its values) before the operation. The Cortex-M4 does arithmetic on 32-bit registers anyway, so promotion is exactly what the hardware does.

• The sum a + b is 300 because the arithmetic happens in int; the wrap to 44 appears only when you store the result in a uint8_t.
• x - y with unsigned bytes gives −5, because both operands became signed int. Many bugs come from assuming an unsigned byte difference wraps to 251 inside an expression.
• Promotion also applies to unary operators: ~a and -a are int.

3. The Usual Arithmetic Conversions

Understanding type casting in embedded C also means knowing the second implicit rule. When the two operands of a binary operator have different types, C converts them to a common type following the usual arithmetic conversions. After integer promotion the rule is: the operand of the lower-ranked type is converted to the higher-ranked one. This ladder shows the order:

4. Truncation: What Happens When You Narrow a Value

Type casting in embedded C often narrows values, so know the result. Narrowing converts a value to a type that cannot hold all of its possible values. For integers, the result is the original value reduced modulo 2^N: the upper bits are simply discarded. This is called truncation. The compiler does not complain unless you enable -Wconversion.

5. Widening and Sign Extension

Widening converts to a larger type and is safe for the value, but how the new upper bits are filled depends on the source type. A signed source is sign-extended (the sign bit is copied); an unsigned source is zero-extended.

6. Explicit Type Casting: Syntax and Purpose

Explicit type casting in embedded C is written by the programmer. An explicit cast tells the compiler to convert a value to another type. The syntax is (type) expression. A cast is a request, not a command to change memory: it creates a new value of the target type.

7. Casting a Pointer to a Hardware Address

This is the type casting in embedded C that has no desktop equivalent: the cast that makes embedded C different from desktop C. A peripheral register lives at a fixed address given in the reference manual. To access it, you convert that integer constant into a pointer to the right type and dereference it:

The same pattern works for any width. The pointer type decides the access size: (volatile uint8_t *) performs byte accesses, (volatile uint16_t *) half-word accesses.

8. Pointer-to-Pointer Casts, Alignment and Strict Aliasing

You can also cast between pointer types: (uint8_t *)&value lets you see the bytes of any object, which is how you inspect memory or send a structure over a serial port. Three rules keep this safe:

• Character types may alias anything. Reading any object through unsigned char * or uint8_t * is always allowed.
• Other aliasing is not allowed. Reading a float through a uint32_t * violates the strict aliasing rule: the optimiser may reorder or remove the access. Use memcpy or a union to reinterpret bits.
• Alignment matters. A uint32_t * must hold an address divisible by 4. Casting a pointer into the middle of a byte buffer can create a misaligned pointer (a hard fault on some Cortex-M accesses, undefined behaviour in C).

9. Dangers of Incorrect Type Casting in Embedded C

10. Best Practices for Type Casting in Embedded C

• Prefer not casting: choose the right type at the declaration.
• When you must cast, cast the operand before the operation, and add a short comment.
• Compile with -Wall -Wextra -Wconversion -Wsign-conversion -Wcast-align and read every warning.
• Use uintptr_t for pointer-to-integer conversions and volatile pointers for hardware.
• Define register addresses once, in a header, as macros or a struct overlay (Lesson 3.2).
• Use memcpy or a union for type punning; never dereference an incompatible pointer cast.
• Use sizeof instead of numeric sizes, and size_t for the results.
• Check ranges before narrowing floats to integers or wide integers to narrow ones.

Key Takeaways — Lesson 3.3

• sizeof is a compile-time operator returning size_t; it works on types (with parentheses), variables and expressions without evaluating them.
• Arrays decay to pointers in function parameters, so sizeof there gives the pointer size.
• Integer promotion widens anything narrower than int to int before arithmetic; the usual arithmetic conversions then bring both operands to a common type.
• Mixing signed and unsigned of the same rank converts to unsigned; f * 2.0 forces double.
• Narrowing truncates (mod 2^N); widening sign-extends signed sources and zero-extends unsigned sources.
• An explicit cast creates a converted value: cast the operand before the operation.
• (volatile uint32_t *)0x40020C14UL turns an address from the manual into a register you can read and write.
• Dangerous casts: truncation, misalignment, aliasing violations and removing volatile. Good type casting in embedded C is rare, deliberate and commented.

Frequently Asked Questions