Pointers: The Fundamentals

3. Your First Pointer Program: Line-by-Line Walkthrough

Let’s dissect every single line of the classic pointer-demo program. Read each comment carefully—the inline annotations explain exactly what is happening at each step.

#include <stdio.h>

int main() {
    // LINE 1: Declare an ordinary integer variable named "num" and
    //         initialize it to 42. The compiler reserves 4 bytes on
    //         the stack (on most systems) and writes the bit pattern
    //         for 42 into those bytes.
    int num = 42;

    // LINE 2: Declare a POINTER-to-int named "ptr" and initialize it
    //         with the address of "num". The "int *" part reads as
    //         "pointer that holds the address of an integer."
    //         The asterisk here is part of the TYPE, not the dereference
    //         operator — this is a common point of confusion.
    int *ptr = #

    // LINE 3: Print the value INSIDE the variable num.
    //         Output: Value of num: 42
    printf("Value of num: %d\n", num);

    // LINE 4: Print the ADDRESS where num lives in memory.
    //         Output: Address of num: 0x7fff1234abcd (varies every run)
    printf("Address of num: %p\n", (void*)&num);

    // LINE 5: Print the value stored INSIDE ptr. Since ptr holds
    //         the address of num, this prints the same address.
    //         Output: Value stored in ptr: 0x7fff1234abcd
    printf("Value stored in ptr (the address): %p\n", (void*)ptr);

    // LINE 6: Dereference ptr — follow the address to num and read its value.
    //         Output: Value pointed to by ptr: 42
    printf("Value pointed to by ptr: %d\n", *ptr);

    // LINE 7: Dereference ptr and WRITE 99 into that memory location.
    //         This actually changes num, because ptr points to num.
    *ptr = 99;

    // LINE 8: Read num directly — it's now 99, because we changed it
    //         through the pointer. Multiple names, same memory.
    //         Output: New value of num: 99
    printf("New value of num: %d\n", num);

    return 0;
}

Notice that the asterisk (*) has two completely different meanings depending on context:

• In a declaration (int *ptr), it means “this variable is a pointer.”
• In an expression (*ptr), it means “give me the value at the address stored in ptr.”

This dual meaning is one of the most confusing aspects of C syntax. Whenever you see an asterisk, ask yourself: Am I reading a declaration or an expression?

4. Memory Map: Seeing What Actually Happens in RAM

The best way to understand pointers is to draw what’s happening in memory. Let’s imagine that num is allocated at address 0x1000 and ptr at address 0x2000 (on a 64-bit system, addresses are 8 bytes):

  ADDRESS      | VARIABLE NAME | VALUE STORED
  -------------+---------------+------------------------------------
  0x1000       | num           | 99  (an integer, 4 bytes)
  0x1004       |               | (next variable's space)
     ...       |               |
  0x2000       | ptr           | 0x0000000000001000  (8-byte address)
  0x2008       |               | (next variable's space)

  The ARROW of pointing:
  ptr (at 0x2000) ———————————► num (at 0x1000)
       contains 0x1000               contains 99

Walk through the program line by line with this diagram:

1. int num = 42; — The OS gives num address 0x1000 and writes 42 there (4 bytes).
2. int *ptr = # — The OS gives ptr address 0x2000 and writes the address 0x1000 there.
3. *ptr = 99; — The CPU reads ptr (gets 0x1000), walks to address 0x1000, and writes 99 at that location. The variable num is now 99, because num is the name for memory at 0x1000.

This is the key realization: num and *ptr are two names for the same piece of memory, as long as ptr points to &num.

5. Pointer Declaration: Reading Right-to-Left

C declarations can be intimidating. Here’s a reliable trick: read them from right to left.

int *ptr;        // "ptr is a pointer to an int"
int **ptr2;      // "ptr2 is a pointer to a pointer to an int"
int *arr[10];    // "arr is an array of 10 pointers to int"
int (*parr)[10]; // "parr is a pointer to an array of 10 ints"

Notice the difference between the last two. The parentheses change everything. int *arr[10] means “an array of 10 pointers,” while int (*parr)[10] means “a pointer to an array.” We’ll explore these in depth later, but for now, just absorb the right-to-left reading pattern.

6. Pointers to Pointers (Indirection)

If a pointer holds the address of another variable, could a pointer hold the address of another pointer? Absolutely. This is called multiple indirection, and while it sounds exotic, it’s essential for things like passing a pointer that a function should modify:

#include <stdio.h>

int main() {
    int value = 42;
    int *p1 = &value;     // p1 points to value
    int **p2 = &p1;       // p2 points to p1

    // Three ways to get to 42:
    printf("%d\n", value);    // directly: 42
    printf("%d\n", *p1);      // one hop through p1: 42
    printf("%d\n", **p2);     // two hops through
 p2 then p1: 42

    // Change value through p2:
    **p2 = 99;
    printf("%d\n", value);    // prints 99

    return 0;
}

Memory diagram for this: