Pointer to pointer

WHAT is it?

Definition Pointer to pointer

A variable that holds the address of a pointer variable. Declared with two asterisks:

int   x   = 42;     // an int
int  *p   = &x;     // p holds address of x
int **pp  = &p;     // pp holds address of p

x → the value 42
p → holds &x (address of x)
pp → holds &p (address of p)

Why does the type need **? A type in C tells the compiler how to interpret the bytes at the target address. When you write *pp, the compiler must know "the thing at pp is itself a pointer," so it needs int **. One * would mean "dereferencing gives an int" — wrong, here dereferencing gives a pointer.

HOW dereferencing peels layers

Each * removes one level of indirection.

Expression	Meaning	Value (using addresses below)
`pp`	address of `p`	`&p` = `0x300`
`*pp`	the value stored in `p`	`&x` = `0x100`
`**pp`	the value stored in `x`	`42`

WHY do we need it? (the 80/20 core)

The 20% of use-cases that cover 80% of real code:

Modifying a pointer inside a function. C passes by value. To change the caller's pointer, you must pass its address → an int **.
Arrays of strings / 2-D dynamic arrays. char **argv, char **lines.
Linked-list/tree edits where you must update the node-pointer itself.

Worked example WHY case 1 — changing a pointer from a function

void alloc_int(int **ptr) {
    *ptr = malloc(sizeof(int)); // *ptr is the caller's pointer
    **ptr = 99;                 // write into the new memory
}
int main(void) {
    int *q = NULL;
    alloc_int(&q);   // pass ADDRESS of q
    printf("%d\n", *q); // prints 99
}

Why pass &q? If we passed q (just a value), the function would change only its local copy — q in main would stay NULL. Passing &q (type int **) lets the function reach back and overwrite q itself.

Worked example WHY case 2 — array of strings

char *names[3] = {"Ann", "Bo", "Cy"};
char **pp = names;      // pp points to names[0]
printf("%s\n", *pp);      // "Ann"  → first string
printf("%s\n", *(pp+1));  // "Bo"   → second string
printf("%c\n", **pp);     // 'A'    → first char of first string

Why this step (*(pp+1))? Pointer arithmetic moves by sizeof(char*), so pp+1 points to names[1]. One * gives the string pointer; a second * would give a single char.

Worked example WHY case 3 — full address chase

int  x  = 10;
int *p  = &x;
int **pp = &p;
*p = 20;        // changes x via p        → x == 20
**pp = 30;      // changes x via pp       → x == 30
*pp = NULL;     // changes p (not x!)     → p == NULL now
// **pp here would now CRASH (dereferencing NULL)

Why does *pp = NULL not touch x? *pp is p. Assigning to it overwrites the pointer p, not the integer x. The level you write to depends on how many * you used on the left.

Common mistakes (Steel-manned)

Flashcards

What does int **pp store?

The address of a pointer variable (a pointer to a pointer).

If pp = &p and p = &x, what is *pp?

The value of p, which is &x (the address of x).

If pp = &p and p = &x, what is **pp?

The value of x — full dereference to the int.

Why pass int ** to a function?

So the function can modify the caller's pointer, since C passes arguments by value.

How many * to modify an int vs an int* inside a function?

One * (pass int*) for an int; two * (pass int**) for a pointer.

What is the type of *pp when pp is int**?

int* — a pointer to int.

In char **argv, what is *argv?

A char* — pointer to the first command-line string.

Why does each * "peel a layer"?

Because dereference means "follow the address one step to the thing it points to."

What happens to **pp if *pp (i.e. p) is NULL?

Undefined behaviour / crash — you dereference a NULL pointer.

Does *pp = NULL change the final value x?

No — it overwrites the pointer p; x is untouched.

Recall Feynman: explain to a 12-year-old

Imagine a treasure. You have a note that says "the treasure is in box A." That note is a pointer. Now you have another note that says "the first note is on the kitchen table." That second note is a pointer to a pointer — it doesn't point to the treasure directly, it points to the note that points to the treasure. To get the treasure you read note 2 → walk to the table → read note 1 → walk to box A → open it. Each * in C is one "walk to where the note says." Two * means two walks, so you reach the treasure (42). One * only gets you to note 1.

Connections

Pointers basics — the single-level foundation this builds on.
Pass by value vs pass by reference — why ** is needed for functions.
Dynamic memory allocation (malloc) — int ** to return allocated memory.
Command line arguments (argv) — char **argv in practice.
Pointer arithmetic — how pp+1 steps by sizeof(pointer).
2-D arrays vs pointer to pointer — subtle differences in memory layout.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, pointer ek aisa variable hai jo kisi doosre variable ka address store karta hai. Ab "pointer to pointer" ka matlab simple hai — ek aisa box jo kisi aur pointer ka address rakhta hai. Jaise int x = 42; phir int *p = &x; (p ke andar x ka address), aur int **pp = &p; (pp ke andar p ka address). Bas ek extra level of indirection add ho gaya, kuch magic nahi.

Yaad rakhne ka rule: har * ek arrow ko follow karta hai, ek layer chheelta hai. *pp aapko p deta hai (yaani &x), aur **pp aapko x ki value 42 deta hai. & upar le jaata hai (layer wrap karta hai), * neeche le jaata hai (layer peel karta hai). Isko mantra ki tarah yaad rakho: "Star peels, ampersand wraps."

Yeh kyun zaroori hai? Sabse bada reason — C mein function ko sab kuch by value milta hai. Agar aap function ke andar caller ka pointer hi change karna chahte ho (jaise malloc se memory de kar), toh aapko us pointer ka address bhejna padega, yaani int **. Agar aap sirf int* bhejoge, function apni local copy change karega, original waisa ka waisa reh jaayega. Isiliye void f(int **p) pattern bohot common hai.

Galti se bachna: *pp ek pointer hai (int*), aur **pp ek value hai (int) — dono interchangeable nahi hain. Arrows ginna seekh lo. Aur agar beech ka link NULL ya garbage hai, toh **pp crash kar dega. Real life examples: char **argv (command line strings), 2-D dynamic arrays, aur linked list ke node edits — sab mein yahi concept kaam aata hai.

WHAT is it?

HOW dereferencing peels layers

WHY do we need it? (the 80/20 core)

Common mistakes (Steel-manned)

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — C Programming

Connections