What You Will Learn

Prerequisites

You should have worked through the earlier lectures in Chapter 8: memory and addresses, the address operator, declaring pointer variables, and assigning addresses to pointers. Make sure you can write int *p = &x; and explain what it means. This free C programming course builds each lecture on the one before, so a quick review of lecture 4 is worth five minutes.

Dereferencing Pointers in C

So far every program in this course has reached a variable by its name. A pointer lets you reach it indirectly, by going through its address. The operator that does this is the indirection operator, also called the dereference operator, and it is written *.

Put * in front of a pointer inside an expression and you get the object the pointer points to. If p holds the address of level, then *p is level: the same storage, not a copy.

int level = 87;
float gain = 4.5f;

int   *lp = &level;
float *gp = &gain;

With these declarations, *lp can be used anywhere level could be, and *gp anywhere gain could be. The base type decides what you get: *lp is an int and *gp is a float.

Two stars, two meanings

The asterisk appears in two different roles, and beginners often mix them up. Position tells you which one you are looking at.

Reading and Writing Through a Pointer

Because *lp is the target itself, you can use it on either side of an assignment. On the right it reads the value. On the left it changes the value of the original variable.

Two identities are worth knowing. Applying the address operator and then the indirection operator brings you back where you started: *&level is simply level. And going the other way, &*lp is just lp. The two operators cancel each other out.

Dereferencing Demo Program

This program reads and writes two variables through pointers, checks the two identities, and then peeks at the bytes of a 32-bit value through a byte pointer.

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

int main(void)
{
    int level = 87;
    float gain = 4.5f;
    int *lp = &level;
    float *gp = &gain;

    printf("read  via pointer: %d and %.1f\n", *lp, *gp);

    *lp = *lp + 3;
    *gp = 9.0f;
    printf("after writing through pointers: level=%d gain=%.1f\n", level, gain);

    printf("*&level = %d, &*lp == lp ? %d\n", *&level, &*lp == lp);

    uint32_t word = 0x11223344;
    uint8_t *bp = (uint8_t *)&word;
    for (int i = 0; i < 4; i++)
        printf("byte %d = 0x%02X\n", i, bp[i]);
    return 0;
}

Build and run

gcc -Wall -Wextra -o deref_demo deref_demo.c
./deref_demo

Expected output on a little-endian PC

read  via pointer: 87 and 4.5
after writing through pointers: level=90 gain=9.0
*&level = 90, &*lp == lp ? 1
byte 0 = 0x44
byte 1 = 0x33
byte 2 = 0x22
byte 3 = 0x11

The first line shows that *lp and *gp read the real values. After the writes, level and gain themselves have changed, even though we never assigned to their names. That is the whole point of indirection. The identity line confirms that the two operators cancel.

The last four lines look surprising at first. The 32-bit value 0x11223344 is stored with its least significant byte at the lowest address, so reading it byte by byte through a pointer gives 0x44 first. This is called little-endian storage, and it is used by x86 PCs and by ARM Cortex-M chips in their normal configuration. On a big-endian machine the order would be reversed. This demo also uses the fact that the language allows you to look at any object as a sequence of bytes through a byte pointer.

Why the Base Type Matters

In lecture 3 we promised to explain why a pointer needs a data type even though every pointer is the same size. The byte demo above is the answer. The pointer bp is a uint8_t *, so following it reads one byte. If the same address were held in a uint32_t *, following it would read four bytes and give you 0x11223344 instead. The address is identical; the base type decides the width and meaning of the read.

(The 16-bit and 32-bit rows assume little-endian storage and a suitably aligned address, which holds for this variable.) Remember the second reason from last time too: the base type sets the step size in pointer arithmetic, which is the topic of the next stretch of this chapter.

Dereferencing in Embedded C Programming

In embedded C programming dereferencing is the mechanism behind memory-mapped input and output. A peripheral register is a memory location at a fixed address from the chip’s reference manual. To control hardware, you form a pointer to that address and dereference it:

#include <stdint.h>

/* Illustrative example for an STM32F4-style GPIOA output data register.   */
/* Do NOT run this on a PC: that address does not exist there.             */
#define GPIOA_ODR  (*(volatile uint32_t *)0x40020014u)

void led_on(void)
{
    GPIOA_ODR |= (1u << 5);      /* set bit 5: drive pin PA5 high */
}

Read the macro from the inside out. 0x40020014u is just a number. The cast (volatile uint32_t *) says “treat this number as the address of a 32-bit register”. The leading * dereferences it, so GPIOA_ODR behaves like a variable that happens to live inside the hardware. Writing to it changes real pin voltages.

Common Mistakes

Best Practices

• Initialise, then check, then dereference.
• Use const on pointers that are only read through.
• Use volatile on pointers to hardware registers.
• Prefer named macros or struct overlays for registers rather than raw addresses scattered through code.
• Set a pointer to NULL once its target is no longer valid.

Key Takeaways

• *p in an expression means the object that p points to.
• You can read it or assign to it, so a variable can be changed without using its name.
• The star in a declaration means “this is a pointer”; the star in an expression means “follow it”.
• *&x is x and &*p is p.
• The base type decides how many bytes a dereference reads.
• Embedded code reaches hardware by dereferencing volatile pointers to fixed addresses.

Conclusion

You now hold the full pointer toolkit for this opening part of the chapter: addresses, the address operator, pointer variables, assignment, NULL and dereferencing. Together they let a function change its caller’s variables, let a driver talk to hardware, and prepare you for pointer arithmetic, arrays, strings and dynamic memory in the lectures ahead. Work through the quiz and interview questions below before moving on. They are the same style of question you will meet in real embedded interviews, and this free C programming course is built to get you ready for exactly that.

Chapter Quiz

Try each question on paper first. Open the answer only after you have committed to your choice.

Multiple choice

Predict the output

int a = 10;
int *p = &a;
*p = *p + 5;
printf("%d", a);

int x = 4, y = 9;
int *p = &x;
int *q = &y;
p = q;
*p = 1;
printf("%d %d", x, y);

int n = 7;
int *p = &n;
int *q = p;
*q = *q * 2;
printf("%d %d", n, *p);

int v = 3;
int *p = &v;
printf("%d %d", *&v, *p == v);

Interview Questions

These are the pointer fundamentals that interviewers for embedded and systems roles ask again and again. Practise saying the answers out loud in your own words.

Frequently Asked Questions