Pointer to pointer — Hinglish notes

5.1.12 · Coding › C Programming

YEH HAI KYA?

Definition Pointer to pointer

Ek variable jo ek pointer variable ka address hold karta hai. Do asterisks se declare hota hai:

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

x → value 42
p → &x hold karta hai (x ka address)
pp → &p hold karta hai (p ka address)

Type mein ** kyun chahiye? C mein type compiler ko batata hai ki target address ke bytes ko kaise interpret karna hai. Jab tum *pp likhte ho, compiler ko pata hona chahiye ki "pp pe jo cheez hai woh khud ek pointer hai," isliye int ** chahiye. Ek * ka matlab hoga "dereference karne pe int milega" — yeh galat hai, kyunki yahan dereference karne pe ek pointer milta hai.

Dereferencing HOW KARTA HAI layers ko peel

Har * ek level of indirection hata deta hai.

Expression	Meaning	Value (neeche diye addresses use karke)
`pp`	`p` ka address	`&p` = `0x300`
`*pp`	`p` mein stored value	`&x` = `0x100`
`**pp`	`x` mein stored value	`42`

KYUN chahiye yeh? (80/20 core)

20% use-cases jo 80% real code cover karte hain:

Ek function ke andar pointer ko modify karna. C value se pass karta hai. Caller ke pointer ko change karne ke liye, uska address pass karna padta hai → ek int **.
Arrays of strings / 2-D dynamic arrays. char **argv, char **lines.
Linked-list/tree edits jahan tumhe node-pointer khud update karna hota hai.

Worked example WHY case 1 — function se pointer change karna

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
}

&q kyun pass karein? Agar humne q pass kiya (sirf ek value), to function sirf apni local copy change karta — main mein q NULL hi rehti. &q pass karna (type int **) function ko allow karta hai ki woh q ko hi overwrite kar sake.

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

Yeh step (*(pp+1)) kyun? Pointer arithmetic sizeof(char*) ke steps mein move karta hai, isliye pp+1 names[1] ki taraf point karta hai. Ek * string pointer deta hai; doosra * ek akela char deta.

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)

*pp = NULL x ko kyun nahi touch karta? *pp hi p hai. Isme assign karna pointer p ko overwrite karta hai, integer x ko nahi. Tum kis level pe likhte ho woh depend karta hai ki left side pe kitne * use kiye.

Common mistakes (Steel-manned)

Flashcards

int **pp kya store karta hai?

Ek pointer variable ka address (ek pointer to a pointer).

Agar pp = &p aur p = &x, to *pp kya hai?

p ki value, jo ki &x hai (x ka address).

Agar pp = &p aur p = &x, to **pp kya hai?

x ki value — int tak poora dereference.

Function ko int ** kyun pass karte hain?

Taaki function caller ke pointer ko modify kar sake, kyunki C arguments by value pass karta hai.

Ek function ke andar int vs int* modify karne ke liye kitne * chahiye?

Int ke liye ek * (int* pass karo); pointer ke liye do * (int** pass karo).

Jab pp int** ho, to *pp ka type kya hai?

int* — int ki taraf pointer.

char **argv mein, *argv kya hai?

Ek char* — pehle command-line string ki taraf pointer.

Har * "ek layer kyun peel" karta hai?

Kyunki dereference ka matlab hai "address follow karo ek step aage jis cheez ki taraf point karta hai."

Agar *pp (yaani p) NULL ho to **pp ka kya hoga?

Undefined behaviour / crash — tum ek NULL pointer dereference kar rahe ho.

Kya *pp = NULL final value x ko change karta hai?

Nahi — yeh pointer p ko overwrite karta hai; x untouched rehta hai.

Recall Feynman: ek 12-saal ke bacche ko explain karo

Ek khazane ki kalpana karo. Tumhare paas ek chit hai jo kehti hai "khazana box A mein hai." Woh chit ek pointer hai. Ab tumhare paas ek aur chit hai jo kehti hai "pehli chit kitchen table pe rakhi hai." Woh doosri chit ek pointer to a pointer hai — yeh seedha khazane ki taraf point nahi karti, balki us chit ki taraf point karti hai jo khazane ki taraf point karti hai. Khazana paane ke liye tum chit 2 padhte ho → table pe jaate ho → chit 1 padhte ho → box A pe jaate ho → kholte ho. C mein har * ek "jahan chit boli wahan jaao" hai. Do * matlab do safar, to tum khazane (42) tak pahunch jaate ho. Ek * sirf chit 1 tak pahunchata hai.

Connections

Pointers basics — single-level foundation jis pe yeh build karta hai.
Pass by value vs pass by reference — kyun functions ke liye ** chahiye.
Dynamic memory allocation (malloc) — allocated memory return karne ke liye int **.
Command line arguments (argv) — practice mein char **argv.
Pointer arithmetic — pp+1 kaise sizeof(pointer) ke steps mein chalti hai.
2-D arrays vs pointer to pointer — memory layout mein subtle differences.