Why a Pointer Needs a Base Type

A pointer stores one address, and an address identifies exactly one byte: the first byte of an object. That is not enough information to read the object. Is it a one-byte character, a four-byte integer or an eight-byte double? The compiler answers this question from the pointer’s declared base type. When you write *p, the compiler generates code that reads as many bytes, starting at the stored address, as the base type occupies.

This is the reason you cannot declare a pointer without saying what it points to. The type is not decoration, it is the instruction that tells the machine how wide the access is and how to interpret the bits.

Suggested image 2: a memory strip with highlighted bytes for char, int and double reads. ALT text: “free embedded C course pointer base type decides bytes read”.

Pointer Size vs Pointed-To Size

Two different sizes are involved, and mixing them up is a classic mistake:

• sizeof(p) is the size of the pointer variable. It must be able to hold any address on the machine, so it is the same for every pointer type: typically 8 bytes on a 64-bit PC and 4 bytes on a 32-bit microcontroller such as an ARM Cortex-M.
• sizeof(*p) is the size of the object being pointed to. It follows the base type: 1 for char, usually 4 for int and float, 8 for double.

Older textbooks print pointer sizes of 2 bytes because they target 16-bit compilers. Modern PCs and the microcontrollers you will use today behave differently, which is why you should always measure with sizeof instead of memorising numbers.

Program: Measure Pointer Sizes with sizeof

Save the following as ptr_sizes.c. It also shows how a byte pointer can examine the individual bytes of a 32-bit value.

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

int main(void)
{
    char   c = 'x';
    int    i = 12;
    float  f = 12.4f;
    double d = 18.3;
    char   *pc = &c;
    int    *pi = &i;
    float  *pf = &f;
    double *pd = &d;

    printf("%-8s %-14s %-14s\n", "pointer", "sizeof(ptr)", "sizeof(*ptr)");
    printf("%-8s %-14zu %-14zu\n", "char *",   sizeof pc, sizeof *pc);
    printf("%-8s %-14zu %-14zu\n", "int *",    sizeof pi, sizeof *pi);
    printf("%-8s %-14zu %-14zu\n", "float *",  sizeof pf, sizeof *pf);
    printf("%-8s %-14zu %-14zu\n", "double *", sizeof pd, sizeof *pd);

    uint32_t word = 0x11223344u;
    uint32_t *pw = &word;
    unsigned char *pb = (unsigned char *)&word;
    printf("\n*pw  = 0x%08X (4 bytes read)\n", (unsigned)*pw);
    printf("*pb  = 0x%02X (1 byte read)\n", *pb);
    for (size_t k = 0; k < sizeof word; k++)
        printf("byte[%zu] = 0x%02X\n", k, pb[k]);
    return 0;
}

$ gcc -Wall -Wextra -std=c11 -o ptr_sizes ptr_sizes.c
$ ./ptr_sizes
pointer  sizeof(ptr)    sizeof(*ptr)
char *   8              1
int *    8              4
float *  8              4
double * 8              8

*pw  = 0x11223344 (4 bytes read)
*pb  = 0x44 (1 byte read)
byte[0] = 0x44
byte[1] = 0x33
byte[2] = 0x22
byte[3] = 0x11

The first column of numbers is always the same, the second follows the base type. On a 32-bit board the first column would read 4 instead of 8, but the second column would stay the same.

What the Byte View Teaches You

The same address was used to read the value through a 4-byte pointer and through a 1-byte pointer. The wide pointer returned the whole number 0x11223344, while the byte pointer returned only 0x44, the byte stored first. The least significant byte comes first in memory on this machine, which is called little-endian order. Almost all ARM Cortex-M and x86 systems are little-endian, while some network protocols use big-endian order. Reading memory through an unsigned char pointer is the standard, well-defined way to look at an object’s raw bytes.

Pointer Types in Embedded Systems

A void * has no base type, so the compiler does not know how many bytes to read and refuses a direct dereference. You must cast it to a concrete pointer type first.

Common Mistakes

• Assuming pointers are 2 bytes. Always use sizeof, since the answer depends on the target.
• Using sizeof on a pointer to get an array length. sizeof(p) gives the pointer size, not the number of elements. Pass the length separately.
• Casting a pointer to a wider type and dereferencing it. Reading 4 bytes where only 1 exists touches neighbouring memory, and it may also be misaligned, which faults on some cores.
• Printing addresses with %d or %u. Use %p with a (void *) cast so 64-bit addresses are not truncated.

Best Practices

• Choose the pointer type that matches the object, not the one that is convenient.
• Use fixed-width types from stdint.h for registers and protocol fields.
• Use size_t and %zu for sizes you print.
• Use unsigned char for byte views, because plain char may be signed.

Conclusion

Pointer types look like a small detail, yet they control every memory access your program makes. Knowing the difference between the size of a pointer and the size of its target will save you from subtle bugs in embedded C programming. Next, in this free C programming course, we use the base type again to understand pointer arithmetic: why adding 1 to an int pointer moves four bytes.

Frequently Asked Questions