5.1.9
Ek pointer sirf "ek address" nahi hota — yeh ek aisa address hai jo yeh jaanta hai ki jis cheez ko yeh point kar raha hai uska size kitna hai . Jab tum p + 1 likhte ho, C 1 byte nahi add karta. Yeh 1 × sizeof(*p) bytes add karta hai, taaki pointer agli element par jump kare, na ki agle byte par. Data type hi "stride length" hoti hai.
Definition Pointer + integerAgar p ek pointer hai type T ki taraf, toh p + n ek aisa address hai jo barabar hai:
address ( p ) + n × sizeof ( T ) n positions door element ki taraf point karta hai, elements mein measure karke, bytes mein nahi.
Key idea yeh hai: pointer arithmetic type ke hisaab se scale hoti hai.
int *p; → p + 1 sizeof(int) (aksar 4) bytes move karta hai.char *c; → c + 1 sizeof(char) = 1 byte move karta hai.double *d; → d + 1 sizeof(double) (aksar 8) bytes move karta hai.
Arrays memory mein contiguously store hote hain. Element arr[i] start se i × sizeof(T) byte offset par hota hai. Hum chahte hain ki p + i, arr[i] ko point kare. Isliye language design hi aise ki gayi hai ki integer add karne par tum exactly ek element boundary par land karo.
Chalte hain isse derive karte hain. Maano ek array T arr[N] byte address A
Har element s = sizeof ( T )
byteaddr ( arr[i] ) = A + i ⋅ s
Ab hum pointer p = arr define karte hain (toh p address A demand karte hain ki *(p + i) ka matlab arr[i] ho. Yeh tab sach hoga jab p + i byte address A + i ⋅ s + ka rule yeh hona chahiye:
p + i ≡ ( byte address of p ) + i ⋅ sizeof ( T )
Isliye yeh equivalence valid hai:
int* ko step karna
int a [ 4 ] = { 10 , 20 , 30 , 40 }; int * p = a; // p -> &a[0] printf ( " %d\n " , * p ); // 10 printf ( " %d\n " , * (p + 2 )); // 30 Yeh step kyun? p + 2 = p ka byte address plus 2 * sizeof(int) = +8 bytes → a[2] = 30 ko point karta hai. Humne byte 2 nahi padha; humne element 2 padha.
Worked example Same offset, alag type, alag byteschar * c = ( char* ) 0x 1000 ; // c + 1 == 0x1001 (jump 1 byte) int * i = ( int* ) 0x 1000 ; // i + 1 == 0x1004 (jump 4 bytes) double* d = ( double* ) 0x 1000 ; // d + 1 == 0x1008 (jump 8 bytes) Yeh step kyun? Numerically same +1 hai, lekin stride = sizeof(*ptr) alag hai. Pointer type hi woh information carry karta hai.
Worked example Ek moving pointer se array walk karnaint a [ 5 ] = { 2 , 4 , 6 , 8 , 10 }; int * p = a; int sum = 0 ; for ( int k = 0 ; k < 5 ; k ++ ) { sum += * p; // current element padho p ++ ; // p = p + 1 -> agla int (4 bytes aage) } // sum == 30 Yeh step kyun? p++ matlab hai p = p + 1, jo ek int ke barabar advance karta hai. 5 increments ke baad p one-past-the-end ko point karta hai (yeh address hold karna valid hai, lekin kabhi deref mat karo).
Recall Dekhne se pehle forecast karoint a[3]; int *p = a; Agar &a[0] ka address 0x200 hai aur sizeof(int)==4 hai, toh p + 2 kaunsa address hold karega? Aur ((char*)p) + 2 ka kya?
Verify:
p + 2 → 0x200 + 2*4 = 0x208 (a[2] ko point karta hai).((char*)p) + 2 → 0x200 + 2*1 = 0x202 (a[0] ke beech mein point karta hai! Yeh usually ek bug hai.)
p + 1 se 1 byte add hota hai."
Kyun sahi lagta hai: Ek pointer hota hi ek number hai (ek address), aur kisi number mein 1 add karne se +1 milta hai. Consistent lagta hai.
Fix yeh hai: C jaanbujh kar pointers ke liye plain integer addition ko override karta hai. p + 1 mein sizeof(*p) bytes add hoti hain taaki yeh agli element par land kare. Agar sach mein +1 byte chahiye, toh pehle char* mein cast karo.
Common mistake "Main do pointers ko saath add kar sakta hoon."Kyun sahi lagta hai: Pointers ka subtraction kaam karta hai (q - p se element count milta hai), toh addition bhi symmetric lagta hai.
Fix yeh hai: p + p illegal hai — "address + address" ka matlab kya hoga? Sirf pointer ± integer aur pointer - pointer defined hain. Do addresses ko add karne ka koi matlab nahi.
n ke liye arr + n ko dereference karna theek hai."
Kyun sahi lagta hai: Arithmetic koi address compute kar deti hai, toh "kaam" kar jaata hai.
Fix yeh hai: Sirf indices 0 .. N-1 ko dereference karna valid hai. arr + N (one-past-end) form karna legal hai, lekin isse dereference karna undefined behavior hai. Usse aage jaana toh UB hai compute karne mein bhi.
*p + 1 aur *(p + 1) ek hi hain."
Kyun sahi lagta hai: Same characters hain, bas spacing alag hai.
Fix yeh hai: * ka binding + se tighter hota hai. *p + 1 = (p par jo value hai) plus 1. *(p+1) = agali element ki value. Yeh bilkul alag hain.
Yeh ek sentence master karo aur pointer ke 80% questions khud solve ho jaate hain:
"Ek T* mein n add karne se woh n * sizeof(T) bytes move karta hai, element n par land karta hai."
Indexing, loops, string walking, 2D arrays, function arg passing — sab kuch isi rule ka reuse hai.
Recall Ek 12-saal ke bachche ko samjhaoSocho ek hallway mein identical lockers ki ek row hai. Ek pointer yeh kehne jaisa hai ki "Main locker #5 ke saamne khada hoon." Agar main "+1" kahu, toh main ek step nahi leta — main agle locker ke saamne chala jaata hoon, woh jitna bhi wide ho. Chote lockers (chars) = ek chhoti step; mote lockers (doubles) = ek badi stride. Pointer hamesha jaanta hai ki uske lockers kitne wide hain, isliye "+1" hamesha seedha agle locker ke saamne land karta hai — kabhi do ke beech mein nahi atak ta.
"Step by TYPE, not by BYTE."
p + n → n steps , har step = sizeof(*p) bytes.
p + 1 address mein kitne bytes add karta hai?sizeof(*p) bytes (ek element), na ki 1 byte.
arr[i] exactly kaunse pointer expression ke barabar hai?*(arr + i) (aur *(i+arr), i[arr] bhi).
int *p ke liye jab sizeof(int)==4 ho, toh p + 3 kitne bytes move karta hai?3 * 4 = 12 bytes.
Kya p + q (do pointers) legal hai? Nahi. Sirf pointer ± int aur pointer - pointer defined hain.
Ek int *p ke liye ((char*)p)+1 aur p+1 mein kyun fark hai? char* mein cast karne se stride = 1 byte ho jaati hai, toh yeh sizeof(int) ki jagah sirf 1 byte aage jaata hai.
*p + 1 aur *(p+1) mein kya fark hai?*p + 1 = p par jo value hai, plus 1. *(p+1) = agli element ki value. * ka binding + se tighter hota hai.
Kya arr + N (last element ke ek baad) form karna legal hai? Kya isse dereference karna legal hai? Isse form karna legal hai; dereference karna undefined behavior hai.
Pointer arithmetic ka woh general rule kya hai jo 80% questions cover karta hai? p + n se n * sizeof(*p) bytes move hoti hain aur element n par land hota hai — "step by type, not by byte."
Scaled arithmetic p plus n
Byte address A plus n times s
Arrays stored contiguously
Lands on element boundary
Walk array with p plus plus
