Arrays and pointers — array name decays to pointer

5.1.10 · Coding › C Programming

WHAT is "decay"?

Teen famous exceptions jahan decay NAHI hoti (naam poori array rehti hai):

==sizeof arr== → poori array ke total bytes deta hai, pointer size nahi.
==&arr== → T(*)[N] deta hai, poori array ka pointer, T** nahi.
String literal jo char[] ko initialize karne ke liye use hota hai (wahan woh array hi rehta hai).

HOW does indexing actually work? (derive from scratch)

Hum claim karte hain ki arr[i] ko *(arr + i) ke roop mein define kiya gaya hai. Ise build karte hain.

Step 1 — arr + i mein arr kya hai? Yeh step kyun? Expression arr + i mein, arr ek value ke roop mein use ho raha hai → yeh decay ho ke &arr[0] ban jaata hai, type T*.

Step 2 — Pointer arithmetic element size ke hisaab se scale hoti hai. Yeh step kyun? T* mein i add karna i bytes add nahi karta; yeh i elements add karta hai. Compiler ko sizeof(T) pata hota hai, isliye: $arr + i \equiv (base address) + i \times sizeof(T) bytes$

Step 3 — Dereference. Yeh step kyun? *(arr + i) us computed address pe stored T ko read karta hai — exactly $i$ -vaan element.

Toh C standard ke according: $arr[i] \equiv *(arr + i)$

Figure — Arrays and pointers — array name decays to pointer

Worked Examples

Worked example 1 —

sizeof decay vs no-decay dikhata hai

int a[10];
int *p = a;                 // 'a' decays -> &a[0]
printf("%zu\n", sizeof(a)); // 40  (10 * 4 bytes)  -- NO decay
printf("%zu\n", sizeof(p)); // 8   (pointer size)  -- p IS a pointer

Step 1 (int *p = a) kyun? Assignment context → a decay hota hai, toh p base address hold karta hai. sizeof(a) = 40 kyun? sizeof ek exception hai: yeh poori array type int[10] dekhta hai ⇒ $10 \times 4$ . sizeof(p) = 8 kyun? p genuinely ek pointer hai, isliye pointer width milti hai.

Worked example 2 — Function ko pass karna: size kho jaata hai

void f(int arr[]) {              // parameter is REALLY int *arr
    printf("%zu\n", sizeof(arr)); // 8, NOT the array size!
}
int main(){ int a[100]; f(a); }

Kyun? Jab tum int arr[] as a parameter likhte ho, compiler ise int *arr mein rewrite kar deta hai. Array call f(a) pe decay ho gayi, isliye function ko kabhi pata nahi chala ki woh 100 lamba tha. Fix: length alag se pass karo: f(a, 100).

Worked example 3 —

&arr ek alag cheez hai

int a[5];
int *p   = a;        // type int*   , points at a[0]
int (*q)[5] = &a;    // type int(*)[5], points at WHOLE array
printf("%p %p\n", (void*)p, (void*)q);   // same numeric address!
printf("%p\n", (void*)(p+1));  // base + 4   (one int)
printf("%p\n", (void*)(q+1));  // base + 20  (one whole array of 5 ints)

Same address lekin alag +1 kyun? p aur q ek hi jagah point karte hain lekin unke types alag hain, isliye pointer arithmetic alag sizes se step karta hai: 4 bytes vs $5 \times 4 = 20$ bytes.

Common Mistakes (Steel-man)

Flashcards

"Array decays to pointer" ka matlab kya hai?

Zyaadatar expressions mein array name T[N] automatically T* mein convert ho jaata hai jo &arr[0] ke barabar hota hai.

Woh 3 contexts kaun se hain jahan array decay NAHI hoti?

sizeof arr, &arr, aur ek string literal jo char[] initialize karta hai.

C mein arr[i] ko kya define kiya gaya hai?

*(arr + i) — pure pointer arithmetic.

3[arr] compile kyun hota hai aur arr[3] ke barabar kyun hai?

Kyunki arr[i] == *(arr+i) == *(i+arr) == i[arr]; addition commutative hai.

void f(int arr[]) ke andar arr ki real type kya hai?

int * — parameter array syntax pointer mein rewrite ho jaata hai; size info kho jaati hai.

int a[10] ke liye sizeof(a)? Aur int *p=a ke liye sizeof(p)?

40 (10×4, no decay) aur 8 (pointer width).

int arr[5] ke liye arr vs &arr ki type?

int* vs int(*)[5].

p vs &arr ke liye pointer +1 alag byte-distances kyun move karta hai?

Yeh pointed-to type ki size se scale hota hai: int* ke liye 4 bytes vs int(*)[5] ke liye 20 bytes.

Kya tum arr = p; likh sakte ho? Kya tum p = arr; likh sakte ho?

Nahi (array name ek lvalue nahi hai jise assign kar sako) ; Haan (pointer reassign theek hai).

Recall Feynman: explain to a 12-year-old

Imagine karo ek platform pe khadi 10 bogion wali train. Train ke side pe painted naam bas yeh batata hai "is train ka agla hissa yahaan hai." Jab tum apne dost ko train ka naam bata ke describe karte ho, tum actually sirf woh jagah point kar rahe ho jahan se woh shuru hoti hai — woh wahaan se bogiyaan ginta hua chal sakta hai. Yahi "front ko point karna" decay hai: naam arrow ban jaata hai jo box #0 ki taraf point karta hai. Lekin agar tum poochho "poori train kitni lambi hai?" (sizeof), toh station ka map jaanta hai ki woh 10 bogiyaan hain — yeh khaas sawaal arrow se bewakoof nahi hota.

Connections

Pointer Arithmetic — decay ki wajah se hi arr+i kaam karta hai.
Passing Arrays to Functions — decay ka practical fallout.
sizeof Operator — decay ka #1 exception.
Multidimensional Arrays — decay sirf outermost dimension ko peel karta hai (int[3][4] → int(*)[4]).
Strings in C — char* vs char[] aur literal decay.
Memory Layout and Addresses — contiguous boxes yeh sab underlie karte hain.