Pointer Arithmetic

Moving Through Memory

💡 Pointer ko ++ karna ek normal number ko ++ karne jaisa nahi hai — ye ek train mein agle dabbe tak jaana hai, na ki agle number tak.

Jab pointer par p++ karte ho, wo memory mein 1 byte aage nahi badhta — wo apne TYPE ke size jitna aage badhta hai. Agar p ek int* hai (4 bytes), p++ karne se address 4 bytes aage jaata hai, taaki agla int element mile.

Ye C ko type-safe banata hai pointer navigation ke liye — tumhe khud byte-counting nahi karni padti, compiler apne aap sahi jagah tak le jaata hai type ke hisaab se.

Do pointers ko subtract kar sakte ho (kitne elements beech mein hain pata karne ke liye), lekin add nahi kar sakte (do addresses ko jodne ka koi meaning nahi hai).

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;

printf("%p\n", p);       // jaise 0x1000
p++;
printf("%p\n", p);       // 0x1004 (4 bytes aage, int ke liye)
printf("%d\n", *p);      // 20

int *end = &arr[4];
printf("%ld\n", end - p); // 3 (kitne int elements beech mein hain)

➕

Pointer ko ++ karna ek normal number ko ++ karne jaisa nahi hai — ye ek train mein agle dabbe tak jaana hai, na ki agle number tak.

1 / 2

⚡ Quick Recap

p++ type ke size jitna aage badhta hai, na ki 1 byte
Do pointers subtract kar sakte ho, add nahi
Arithmetic type-aware hoti hai — compiler khud sahi jagah tak le jaata hai

Is page mein (2 subtopics)

C mein ek array ke "ek element aage" tak pointer le jaana valid hai (jaise loop conditions mein end pointer), lekin us position ko dereference karna undefined behavior hai. Isse "one past the end" rule kehte hain — bahut C libraries aur STL-jaisi patterns isi trick ka use karte hain.

Do alag arrays ke pointers ko subtract ya compare karna undefined behavior hai — sirf same array ke andar ke pointers ko meaningfully compare kar sakte ho.

int arr[5] = {1, 2, 3, 4, 5};
int *end = arr + 5;   // VALID — ek position aage (dereference mat karo)

for (int *p = arr; p < end; p++) {
  printf("%d ", *p);  // classic pointer-based loop
}

// int *bad = arr + 100; // valid to create, dereference karna UB hai

⚠️Common Mistake: arr + 100 (agar array sirf 5 elements ka hai) create karna technically allowed hai lekin dereference karna undefined behavior hai — crash ho sakta hai, ya chup-chaap galat data mil sakta hai.

Same array ke andar pointers ko relational operators (<, >, <=, >=, ==) se compare kar sakte ho — ye batata hai kaun pointer memory mein pehle aata hai. Ye bahut common hai loop termination conditions mein (jaise upar ka example: p < end).

int arr[5] = {10, 20, 30, 40, 50};
int *p1 = &arr[1];
int *p2 = &arr[3];

if (p1 < p2) {
  printf("p1 array mein pehle aata hai\n");
}

printf("%ld\n", p2 - p1); // 2 (kitne elements beech mein hain)

💡Tip: p2 - p1 tumhe "elements ka farq" deta hai, "bytes ka farq" nahi — C automatically type ke hisaab se divide kar deta hai. Ye pointer arithmetic ka hi extension hai.

← Previous🔗 Pointers & Arrays Next →🎯 Pointers to Pointers

Code10x

Pointer Arithmetic

Valid vs Invalid Pointer Arithmetic

Pointer Comparison