What Is Dereferencing in C?

A pointer variable stores an address. By itself an address is just a number. Dereferencing means following that number to the memory location it names and working with the object stored there. The operator that does this is the unary asterisk, written *, and it is called the indirection operator or dereference operator.

A handy way to read it aloud is “the value at the address”. So *ps is read as “the value at the address held in ps”. Whatever the pointer points to, *ps behaves exactly like that object: you can read it, assign to it, increment it or pass it to printf.

Suggested image 1: a labelled box-and-arrow picture of a pointer variable and its target variable. ALT text: “free C programming course dereferencing a pointer with the indirection operator”.

Two Meanings of the Asterisk

The star character appears in two different roles, and beginners often mix them up. Keep this table in mind for the whole embedded C programming journey.

Pointer Dereference Rules: *p Stands in for the Variable

Once ps holds the address of speed, the expression *ps is an alias for speed. Every statement you can write with the variable you can also write with the dereferenced pointer. The table shows equivalent pairs for an int speed with ps = &speed and a float temp with pt = &temp.

Working Example: Reading and Writing Through a Pointer

Save this as deref_demo.c. It is a small original program that changes a speed and a temperature using only pointers, then lets you type a new speed that scanf stores directly through the pointer.

#include <stdio.h>

int main(void)
{
    int   speed = 40;
    float temp  = 36.5f;
    int   *ps   = &speed;
    float *pt   = &temp;

    *ps = 90;                  /* same as: speed = 90;      */
    (*ps)++;                   /* same as: speed++;         */
    float adj = *pt + 10.0f;   /* same as: temp + 10.0f     */

    printf("speed = %d, *ps = %d, *(&speed) = %d\n", speed, *ps, *(&speed));
    printf("temp  = %.1f, *pt = %.1f, adj = %.1f\n", temp, *pt, adj);

    printf("Enter a new speed: ");
    if (scanf("%d", ps) == 1)         /* ps already holds &speed */
        printf("speed is now %d\n", speed);
    return 0;
}

Build and run it:

$ gcc -Wall -Wextra -std=c11 -o deref_demo deref_demo.c
$ ./deref_demo
speed = 91, *ps = 91, *(&speed) = 91
temp  = 36.5, *pt = 36.5, adj = 46.5
Enter a new speed: 77
speed is now 77

Notice three things. First, speed became 91 even though we never wrote to it by name. Second, temp stayed at 36.5 because we only read it through pt. Third, scanf wanted an address as its second argument, and ps already is one, so we passed ps without an extra &.

Understanding *(&x) Equals x

The address-of operator and the dereference operator are inverses. The expression &speed produces the address of speed, and applying * to an address gives back the object stored there, which is speed. Therefore *(&speed) is the same thing as writing speed. The program above prints all three forms and they show the same number, which proves the point.

Dereferencing in Real Embedded C Programming

On a microcontroller, peripherals are exposed as memory-mapped registers. Firmware writes to them by dereferencing a pointer whose value is the register address. A simplified pattern looks like this (the address is only an example, real values come from your chip’s reference manual):

#include <stdint.h>

#define LED_PORT_ADDR  0x40020014u

void led_on(void)
{
    volatile uint32_t *port = (volatile uint32_t *)LED_PORT_ADDR;
    *port |= (1u << 5);   /* set bit 5 of the register */
}

Do not run that on a PC: the address does not exist there and the program would crash. It shows why dereferencing matters so much in a free embedded C course. The word volatile tells the compiler the register can change on its own, so every * access must really happen.

Common Dereferencing Mistakes

Best Practices

• Initialise every pointer at the moment you declare it.
• Use a descriptive name so *ps and *pt tell the reader what they touch.
• Use const (for example const int *p) when the function only reads through the pointer.
• Use volatile for pointers to hardware registers.
• Print with %p and a (void *) cast when you need to see an address, never %u.

Conclusion

Dereferencing turns a pointer from a plain number into a handle on real data. With it you can change a caller’s variable from inside a function, walk through arrays, and program hardware registers, which is why every serious embedded C programming course spends time on it. In the next lecture of this free C tutorial we will ask an important question: how does the compiler know how many bytes to read when you write *p? The answer lies in the pointer’s type.

Frequently Asked Questions