Published on

Understanding C Pointers and Double Pointers Through a Classroom Metaphor

Authors
  • avatar
    Name
    Mike
    Twitter

🏫 Understanding C Pointers and Double Pointers Through a Classroom Metaphor

Pointers in C can be hard to grasp at first. Let’s make them easier by thinking about them in terms of a classroom, a teacher, and a stack of notecards.

✨ Part 1: The Classroom Story (No Code Yet)

Imagine you’re a student in a classroom.

  • At the front of the room is a big bookshelf where you and other students can keep your study materials.
  • You also have a stack of notecards on your desk for quick notes.
  • The teacher manages who can use the bookshelf and how much space they get.
  • And sometimes you call in a friend to help with tasks.

📒 Your Notecards

  • Each notecard is a quick place to jot something down.
  • You can write information directly on the card, or just write down a shelf number where something is stored on the bookshelf.
  • When class ends, you throw away all your notecards.

🗄 The Bookshelf

  • The bookshelf is big and shared by everyone.
  • You can’t just walk up and use it — the teacher insists that you ask first.
  • If the teacher finds space, they give you a shelf number written on a notecard.
  • If not, they say “Sorry, no room.”
  • When you’re finished with a shelf, you must tell the teacher so the space can be used again.

📖 Books

  • The books are your actual study materials.
  • Small books might fit directly on a notecard.
  • Larger ones belong on the bookshelf, with the notecard pointing to their location.

🧑 Friends

Sometimes you call in a friend to help:

  • If you hand them a notecard with a shelf number, they can go to the bookshelf and rearrange the books for you.
  • But if they ask the teacher for a new shelf, the teacher gives them a notecard.
  • Your friend doesn’t know what to do with it, so when they leave, they throw it away.

📘 Solving the Problem

To fix this:

  • Instead of just letting your friend get their own notecard, you give them one of your own blank notecards.
  • When the teacher hands them a shelf number, they write it directly on your card.
  • Now, when they leave, you still have the updated shelf number.

🔍 Part 2: Mapping the Story to C Pointers

Now let’s connect the metaphor to C programming concepts.

📒 Stack (Your Notecards)

  • The stack is your quick, personal workspace.
  • Each notecard is a variable stored on the stack.
  • When a function ends, its notecards are thrown away.
void study() {
    int x = 42;  // a value written directly on a notecard
} // x disappears when the function ends

🗄 Heap (The Bookshelf)

  • The heap is large, shared, and controlled by the operating system.
  • To get space, you ask using malloc.
  • If space is available, malloc gives you a memory address (a shelf number).
int *p = malloc(sizeof(int)); // teacher gives you a shelf
if (p != NULL) {
    *p = 42;  // put a book on the shelf
}
free(p); // tell the teacher you're done

⚠️ If you don’t free(p), the shelf remains full even if you don’t need it anymore (memory leak).

🖊 Pointers (The Notecards with Shelf Numbers)

  • A pointer is a notecard with a shelf number written on it.
  • You can follow the number to access the book.
int book = 10;   // book written directly on a card
int *card = &book; // card points to the book
printf("%d\n", *card); // use the card to read the book

🧑 Functions and Pointers

  • If you give your friend (a function) just the shelf number, they can read or change the book.
  • But if they ask for a new shelf, their notecard disappears when they leave.
  • In the following code, a pointer is being passed to the function, but this won't work as you may expect
    • Why?

      Because C passes parameters by copying them, we are essentially passing a pointer that points to an irrelevant location And since we are getting a new memory address when we call malloc There is no way to propagate the memory address location of the newly allocated space back to the caller

void allocateWrong(int *p) {
    p = malloc(sizeof(int));  // teacher gives friend a shelf
    *p = 99;                  // friend writes a book
} // friend's notecard is thrown away

When you return to your desk, you don’t know where the book is.

📘 Double Pointers (Letting Your Friend Update Your Card)

The solution is to give your friend one of your own notecards so they can update it for you.

void allocateRight(int **p) {
    *p = malloc(sizeof(int)); // teacher gives friend a shelf
    if (*p != NULL) {
        **p = 99;             // put the book on the shelf
    }
}

int *card = NULL;
allocateRight(&card); // give friend your notecard
printf("%d\n", *card); // your notecard now has the shelf number
free(card);            // clean up when done

⚠️ This is the essence of a double pointer:

  • A single pointer is a shelf number.
  • A double pointer is the address of the card itself.
  • We are passing the memory location of the pointer that we will use to access the desired memory
    • So, we use that memory address to to update the memory address that that pointer points to

🎯 Key Lessons

  • Stack (notecards): fast, temporary, disappears when a function ends.
  • Heap (bookshelf): big, shared, must be requested and freed manually.
  • Pointer (card): just a shelf number, not the book itself.
  • Double pointer: a way to give functions access to your card, so they can update it directly.

✅ By first imagining a classroom with notecards, a bookshelf, and a teacher, the behavior of C pointers and double pointers becomes much easier to understand.

Discuss on Twitter