Pointers & Arrays

Two Sides of the Same Coin

💡 Array aur pointer itne connected hain ki array ka naam khud ek pointer ki tarah behave karta hai — jaise ek train ka naam bologe to automatically uske pehle dabbe (engine) ka pata mil jaata hai.

Array ka naam, jab kisi expression mein use hota hai, "decay" hoke pehle element ke pointer mein badal jaata hai. arr aur &arr[0] same address dete hain.

Isi wajah se array ko pointer arithmetic se bhi access kar sakte ho: arr[i] aur *(arr + i) exactly same cheez hain — compiler dono ko same machine code mein convert karta hai.

Farq bhi hai: pointer ko reassign kar sakte ho (p = someOtherAddress), array ke naam ko nahi — array khud ek "constant pointer" jaisa hai jiski memory location fix hoti hai.

int arr[3] = {10, 20, 30};
int *p = arr;   // array name = pointer to first element (no & needed!)

printf("%d\n", arr[1]);     // 20
printf("%d\n", *(p + 1));   // 20 — same thing!
printf("%d\n", *(arr + 1)); // 20 — array bhi pointer arithmetic support karta hai

🔗

Array aur pointer itne connected hain ki array ka naam khud ek pointer ki tarah behave karta hai — jaise ek train ka naam bologe to automatically uske pehle dabbe (engine) ka pata mil jaata hai.

1 / 2

⚡ Quick Recap

Array ka naam decay hoke pointer ban jaata hai
arr[i] aur *(arr+i) same cheez hain
Array name reassign nahi ho sakta, pointer ho sakta hai

Is page mein (2 subtopics)

int *p aur int (*p)[5] bilkul alag cheezein hain — pehla ek int ka pointer hai (array decay hone ke baad first element ko point karta hai), doosra poore 5-element array ka pointer hai. Dono ko increment karne se bilkul alag results milte hain.

p++ (jaha p int* hai) 4 bytes (ek int) aage badhta hai. p++ (jaha p int(*)[5] hai) 20 bytes (poora array, 5 ints) aage badhta hai — ye interview mein aksar confuse karne ke liye pucha jaata hai.

int arr[5] = {1, 2, 3, 4, 5};

int *p1 = arr;           // pointer to int (first element)
int (*p2)[5] = &arr;     // pointer to the whole array

printf("%p\n", p1);
printf("%p\n", p1 + 1);  // 4 bytes aage

printf("%p\n", p2);
printf("%p\n", p2 + 1);  // 20 bytes aage (poora array skip)

⚠️Common Mistake: int *p = &arr; likhna compile warning/error dega — &arr ka type int(*)[5] hai, int* nahi. Dono syntax alag hai aur mix nahi kar sakte bina explicit cast ke.

Jab array function mein pass karte ho, C ACTUALLY poora array copy nahi karta — sirf uska decayed pointer (first element ka address) pass hota hai. Isliye function signature mein void f(int arr[10]) aur void f(int *arr) exactly same cheez hain — compiler dono ko same treat karta hai.

Isi wajah se function ke andar sizeof(arr) galat answer deta hai (sirf pointer ka size, jaise 8 bytes) — array ka asli size function ko nahi pata, isliye size hamesha separately parameter ke roop mein pass karna padta hai.

// Ye teeno signatures EXACTLY same hain compiler ke liye:
void f1(int arr[10]) { }
void f2(int arr[]) { }
void f3(int *arr) { }

void printSize(int arr[]) {
  printf("%lu\n", sizeof(arr));  // 8 (pointer size), NA ki poore array ka size!
}

💡Tip: Function ke andar array ka asli size kabhi nahi pata chalta sirf array parameter se — hamesha ek alag size parameter pass karo, jaise void printArray(int arr[], int size).

← Previous👉 Pointers — Basics Next →➕ Pointer Arithmetic

Code10x

Pointers & Arrays

Pointer to an Entire Array vs Pointer to First Element

Passing Arrays to Functions — What Really Happens