What Are Pointers and How Do I Use Them?

After this lesson, you will be able to:

• Explain the difference between a variable’s value and its memory address
• Declare pointer variables and assign them using the & (address-of) operator
• Dereference a pointer with * to read and write the value at the pointed-to address
• Distinguish between * in a declaration (pointer-to) and * in an expression (dereference)
• Trace pointer code using box-and-arrow memory diagrams

Pulling Back the Curtain

In Java, when you write ArrayList<Integer> list = new ArrayList<>(), the variable list holds a reference — an invisible pointer to the object on the heap. You never see the address, never manipulate it directly, never think about it.

C rips that curtain away. In C, you can see the address of any variable, store it in another variable, and follow it to read or modify the original. This is what a pointer is — a variable that holds a memory address.

Pointers are what make C powerful enough to build operating systems. They’re also what make C dangerous enough to crash them.

Addresses, Pointers, and Dereferencing

Every Variable Has an Address

Every variable lives somewhere in memory. The & operator gives you that address:

int x = 42;
printf("Value of x:   %d\n", x);
printf("Address of x: %p\n", (void *)&x);

Value of x:   42
Address of x: 0x7ffd5e8a3c2c

That hex number is where x lives in memory. It’s a real location on your computer’s RAM.

Declaring Pointers

A pointer variable stores an address. Declare it with *:

int *p;           // p is a pointer to an int
double *q;        // q is a pointer to a double
char *s;          // s is a pointer to a char

Key Insight: Read pointer declarations right-to-left: int *p means “p is a pointer to an int.” The * in the declaration means “pointer to.” This is different from the * used for dereferencing (which comes next).

Making a Pointer Point to Something

Use & to get a variable’s address, then assign it to a pointer:

int x = 42;
int *p = &x;      // p now points to x

In memory:

  Variable   Address      Value
  ┌──────┐
  │  x   │  0x1000  →   [  42  ]
  └──────┘
  ┌──────┐
  │  p   │  0x1008  →   [0x1000]  ──→ points to x
  └──────┘

p doesn’t contain 42. It contains the address where 42 lives.

Dereferencing: Following the Arrow

The * operator (dereference) follows the pointer to access the value it points to:

int x = 42;
int *p = &x;

printf("p holds address: %p\n", (void *)p);    // 0x1000
printf("*p follows it:   %d\n", *p);            // 42

You can also write through a pointer:

Predict: What do you think this code prints? If p points to x, and we write 99 through *p, what happens to x? Work it out before reading the answer.

*p = 99;            // Changes x through the pointer
printf("x is now: %d\n", x);    // 99!

Key Insight: *p on the left side of = writes to the location p points to. *p on the right side reads from it. The pointer itself (p) holds the address; the dereferenced pointer (*p) accesses the value at that address.

The Two Faces of *

This trips everyone up: * means two different things depending on context:

From Java: Java references are invisible pointers. When you write obj.method(), Java automatically dereferences the reference to find the object. In C, you do this explicitly: *p follows the pointer, p->field follows a struct pointer. The mechanism is the same — C just makes you do it by hand.

NULL Pointers

A pointer that points to nothing should be set to NULL:

int *p = NULL;      // Points to nothing

Dereferencing a NULL pointer crashes your program (segmentation fault). Always check:

if (p != NULL)
{
    printf("Value: %d\n", *p);
}

Common Pitfall: An uninitialized pointer contains a garbage address — it points to some random location in memory. Dereferencing it might crash, or worse, silently corrupt data. Always initialize pointers to either a valid address or NULL.

Memory Diagrams Are Your Best Tool

Draw these for every pointer problem:

  int a = 10;     int b = 20;     int *p = &a;

  ┌───┐           ┌───┐           ┌─────┐
  │ a │ = 10      │ b │ = 20      │  p  │ ──→ a
  └───┘           └───┘           └─────┘

  *p = 30;        // a is now 30
  p = &b;         // p now points to b
  *p = 40;        // b is now 40

  Final: a = 30, b = 40

The Trick: When pointer code confuses you, draw boxes. One box per variable, arrows from pointers to what they point to. Trace each line of code by updating the diagram. This technique works for every pointer problem you’ll encounter.

Pointers Unlock Everything

You now understand the core mechanism: & gets an address, * follows it. That’s the foundation for everything in Series 3 — and a lot of what comes after.

Next lesson: pass-by-pointer. Remember the swap function that didn’t work in Lesson 2.9? With pointers, you can finally fix it. Pointers let functions modify their caller’s variables — the missing piece from Series 2.

Big Picture: Pointers are why C can build operating systems. They give you direct access to memory, let functions modify external data, enable dynamic memory allocation, and connect to hardware. Every remaining topic in this course — dynamic arrays, structs, linked lists, file I/O, system calls — builds on what you learned in this lesson.