Reading Ahead Without Moving

A frequent point of confusion is the difference between computing an address and storing it. Look at these two lines for an int pointer p that points at the start of an array:

int v = *(p + 2);   /* read element 2, p is unchanged */
p += 2;             /* move p itself two elements ahead */

The expression p + 2 creates a temporary address two elements ahead. The star then reads from it. Nothing is assigned back to p, so p still points at element 0. In contrast, p += 2 is an assignment, so p now holds the new address and every later use of *p sees element 2.

Suggested image 4: two strips of array cells, one showing a read at offset two and one showing the pointer moved. ALT text: “free embedded C course pointer moves versus pointer expression”.

Subtracting Two Pointers

When two pointers of the same type point into the same array, their difference tells you how many elements lie between them. The result type is ptrdiff_t, declared in stddef.h, a signed integer wide enough for any pointer difference. Print it with the %td format. Like all pointer arithmetic, the result counts elements, not bytes.

Program: Walk an Array with Pointers

Save this as ptr_walk.c. It reads ahead, moves the pointer, subtracts pointers, and finally sums the array with a begin and end pointer.

#include <stdio.h>
#include <stddef.h>

int main(void)
{
    int a[6] = {5, 10, 15, 20, 25, 30};
    int *p = a;

    printf("*(p+2) = %d, p still at index %td\n", *(p + 2), p - a);

    p += 2;
    printf("after p += 2 : index %td, *p = %d\n", p - a, *p);

    int *q = &a[5];
    ptrdiff_t gap = q - p;
    printf("q - p = %td elements (%td bytes)\n", gap, (char *)q - (char *)p);

    int *end = a + 6;      /* one past the last element: legal to form */
    int sum = 0;
    for (int *it = a; it != end; it++)
        sum += *it;
    printf("sum via pointer walk = %d\n", sum);
    return 0;
}

$ gcc -Wall -Wextra -std=c11 -o ptr_walk ptr_walk.c
$ ./ptr_walk
*(p+2) = 15, p still at index 0
after p += 2 : index 2, *p = 15
q - p = 3 elements (12 bytes)
sum via pointer walk = 105

The first line proves that reading *(p + 2) left p at index 0. The second shows that p += 2 did move it. The subtraction q – p gives 3 elements, which equals 12 bytes for 4-byte ints, confirming that the language counts in elements. The final loop adds 5 + 10 + 15 + 20 + 25 + 30 = 105.

Keeping Pointers on Valid Memory

When you move a pointer, nothing guarantees that it still refers to a variable of the right type, or to any valid object at all. The compiler decides where variables live, and you do not control the order. The only layout you can rely on is that array elements sit one after another. That is why pointer arithmetic is meant for arrays.

Pointer Walk Versus Array Index

You can write the same loop in two styles. The index style uses a counter and the subscript operator. The pointer style uses a begin and an end pointer. Both compile to similar machine code on modern compilers, so choose the one that makes your intent clearer.

When you need the position inside a pointer loop, subtract the base: it - a gives the index. When you only need the values, the pointer style removes one variable. In firmware that processes a stream of samples, this is a common and tidy pattern.

Real-World Use: Ring Buffer Pointers

A UART receive ring buffer keeps a head and a tail pointer inside a fixed array. After each byte the pointer is incremented, and when it reaches the end it wraps back to the start. The one-past-the-end rule is what makes the comparison head == buffer + SIZE legal. Subtracting the pointers gives how many bytes are waiting, handled with care around the wrap point.

Troubleshooting Checklist

• Garbage values when reading: check the pointer did not move past the end.
• Off-by-one results: remember that end points past the last element, so the loop test uses != or <.
• Wrong byte distance: pointer subtraction gives elements, cast to char * if you need bytes.
• Compiler warnings about incompatible pointer types: you are subtracting different types, fix the declarations.

Best Practices

• Keep the original base pointer, and move a copy when you need to walk.
• Prefer the begin/end pointer pair for loops.
• Validate lengths received from outside before you step through a buffer.
• Use a bounds check in security-sensitive code instead of trusting incoming sizes.

Conclusion

You can now tell apart reading ahead and moving, measure the distance between pointers and keep your pointers inside safe bounds. These skills turn pointers from a source of crashes into a precise tool for embedded firmware. The final lecture of this block gathers everything from dereferencing to pointer arithmetic into a quiz and a set of interview questions for your free C programming course practice.

Frequently Asked Questions