Pointers ko samjhein
Pointer objects, targets, aliasing, null values aur function parameters se indirect access ka clear model banayein.
Is chapter mein10 sections
Pointer code ko kisi object tak indirectly pahunchne deta hai. Yeh tab useful hai jab function ko caller ki value ya kisi buffer ka access chahiye. Pointer aur uske target ko do alag objects samajhkar shuru karein.
Ideas ko saath rakhkar samajhna hai? Concept guide kholein.
1. Pointer object aur target alag hain
int *p mein p pointer-to-int type ka hai. Declaration ka * type describe karta hai; woh doosra object read nahi karta. Expression *p mein unary * indirection hai: suitable valid pointer ke saath expression pointed-to object designate karti hai. Context symbol ka role decide karta hai.
int count = 4;
int *p = &count;
*p = 9;
Initializer &count, count ka pointer deta hai. *p ke through assignment count change karti hai; p mein stored address nahi. Pointer object ka apna type, storage aur lifetime hai. Target ka bhi apna type, storage aur lifetime hai.
2. Pointer copy karna relationship copy karta hai
int left = 4;
int right = 8;
int *p = &left;
int *q = p;
p = &right;
*q = 6;
q = p ke baad dono pointer values left refer karti hain. Yeh aliasing hai: different expressions same object access kar sakti hain. Later p reassign karne se sirf p change hota hai, q redirect nahi hota. q ke through write ab bhi left change karti hai. Pointer copy karne se target object copy nahi hua, na usko extra lifetime mili.
Visual model ke saath samjhein
Do pointers aur unke targets follow karein
VISUAL MODEL
Pointer copy karein, ek copy redirect karein aur dono ke through write karein. Arrows batate hain ki har pointer value kis object ko refer karti hai.
Function ke andar int left = 4; aur int right = 8; se shuru karein.
int *p = &left;int *q = p;p = &right;*q = 6;*p = 9;
pPoint karta haiInitializer tak nahi pahuncheqPoint karta haiInitializer tak nahi pahuncheleft4right8left aur right initialise hain. Pointer objects p aur q ke initializers tak abhi nahi pahunche.
Poore trace mein left aur right live aur writable hain. Arrows relationships dikhate hain; actual pointer representation implementation par depend karti hai.
Poora trace padhein
- left aur right initialise hain. Pointer objects p aur q ke initializers tak abhi nahi pahunche.
- p ko left ka pointer mila. left ki value p mein copy nahi hui; p pointer value hold karta hai.
- q ko p ki pointer value ki copy mili. Ab dono left ko refer karte hain.
- p ab right ko refer karta hai. q apni copied pointer value ki wajah se ab bhi left ko refer karta hai.
- q ke through 6 write karne se left badla. q khud ab bhi left ko refer karta hai.
- p ke through 9 write karne se right badla. Kaunsa integer badlega, yeh decide karne se pehle pointer ka current target dekhein.
3. Pointer parameters bhi value se pass hote hain
#include <assert.h>
static void set_to_seven(int *destination)
{
*destination = 7;
}
int main(void)
{
int score = 4;
set_to_seven(&score);
assert(score == 7);
return 0;
}
Function ko address ki copy milti hai, phir woh copied pointer se caller ke live object ko designate karta hai. C ab bhi argument value ko value se pass karti hai; target change ho sakta hai kyunki dono sides same object access kar sakti hain. Parameter khud reassign karne se caller ka pointer reassign nahi hoga. Jab interface ko caller ka pointer object update karna ho, pointer-to-pointer use ho sakta hai.
Is example ke contract ko valid writable int target chahiye. Different interface mein null check ho sakta hai, lekin woh lifetime, bounds ya type contract ka substitute nahi. Function kya accept karta hai woh state karein; har non-null pointer usable hai aisa imply na karein.
4. Null ka matlab object ya function target nahi
Null pointer objects ya functions ke pointers se unequal compare hota hai. C17 mein value zero wali integer constant expression, ya uska void * cast, null pointer constant hai; NULL macro <stddef.h> jaise headers dete hain. Source-level zero convention ka matlab all-zero pointer representation ya hardware address zero required hona nahi.
int value = 4;
int *optional = NULL;
assert(optional == NULL);
optional = &value;
if (optional != NULL) {
*optional = 8;
}
Non-null value bhi stale, allowed array range ke bahar, misaligned, ya access ke type ke liye unsuitable ho sakti hai. Uninitialized automatic pointer usable “random address” nahi hai. Usko initialize karein aur har operation ke liye target valid rakhein. C23 nullptr aur nullptr_t add karta hai; null dereference valid nahi banata.
5. Type aur permission ab bhi important hain
const int *view us view se integer change karna restrict karta hai; int *const fixed pointer object ko initialization ke baad nonmodifiable banata hai. Dono declarations different cheez protect karti hain. Koi bhi ownership ya extra lifetime nahi deti. Converted object pointer void * mein hold karke rules ke according wapas convert ho sakta hai; standard C void * arithmetic ya void value ka direct dereference allow nahi karti.
Function pointers alag topic hain; object pointer ya int * ko function ke liye safely use kar sakte hain yeh assume na karein. Sab pointer types ka size same hai yeh bhi assume na karein. Live objects ke correctly typed pointers se shuru karein, phir interface ko zaroorat ho tab specific conversion rules padhein.
Primary references aur aage padhne ke liye
- WG14 N1570 — public C11 committee draft: 6.2.4, 6.3.2.3, 6.5.3.2, 6.7.6.1. Yeh stable rules C17 baseline ko support karte hain; yeh draft final ISO publication nahi hai.
- WG14 N3096 — public C23 draft: 6.3.2.3 and the nullptr/nullptr_t facilities. Draft wording; implementation support separately check karein.
Pointer, uski value aur uska target
Idea compare karein, follow karein aur samjhayein
Pointer object ek pointer value store karta hai. Valid value ke zariye expression kisi doosre object ko refer kar sakta hai. Pointer ki stored value badalna aur target ki value badalna alag actions hain.
Yeh kab kaam aata hai Pointer assignment, ek object tak shared access aur pointer lene wale functions padhte waqt yeh difference kaam aata hai.
Ideas ko saath rakhkar padhein
- Pointer object
- Variable p ka apna storage aur pointer type hai.
- Pointed-to object
- int object left ka alag storage aur apni value hai.
Sirf p badalne se left nahi badalta.
- p = &right
- p mein doosri pointer value store hoti hai.
- *p = 6
- p se abhi designate hone wale int object mein 6 store hota hai.
Pehle left side padhein: badal kaunsa object raha hai?
- Pointer value copy karna
- int *q = p se q ko p ki abhi wali value milti hai.
- Target ki value copy karna
- int saved = *p ek int value ko alag int object mein rakhta hai.
Dono operations q ko p ke baad ke changes se automatically nahi jodte.
Reasoning ko follow karein
Neeche saare objects alive rehte hain. Numeric memory addresses imagine karne ke bajay named objects follow karein.
C17 · diye gaye context ke illustrative fragments
int left = 4, right = 8;int *p = &left;int *q = p;p = &right;*q = 6;
- Do int objects banayein
left ki initial value 4 aur right ki 8 hai. Dono ki stored value alag hai.
- p initialize karein
&left, left ka pointer deta hai. Declaration se p ko yeh value milti hai.
- p se q initialize karein
q ko p ki abhi wali pointer value ki copy milti hai. Dono values left ko point karti hain.
- p redirect karein
p = &right se p badalta hai. q ko dobara assign nahi kiya, isliye woh abhi bhi left ko point karta hai.
- q ke through write karein
*q = 6 se left ki value 6 hoti hai. right 8 rehta hai; p, right ko aur q, left ko point karta hai.
Common misconceptions
Yeh statements misleading hain. Kyun, yeh samajhne ke liye har statement kholein.
MisconceptionCopied pointer original pointer variable ko follow karta rehta hai.
Value us samay copy hoti hai. Pointer object p ko khud refer karne ke liye suitable pointer-to-pointer type chahiye.
MisconceptionNon-null pointer ko hamesha dereference kar sakte hain.
Non-null sirf null value ko exclude karta hai. Target alive, correctly aligned aur expression ke type se accessible bhi hona chahiye.
MisconceptionCast invalid pointer ko theek kar deta hai.
Cast type conversion request karta hai. Woh live target object nahi banata aur valid storage ke bahar access nahi deta.
Thoda aur depth meinOptional technical detail
Picture ki limit samjhein
Box aur arrow relationship dikhate hain. C har pointer ko simple numeric RAM address nahi maanta, aur har pointer type ka size same hona zaroori nahi.
Pointer arithmetic ka alag contract hai
Object pointers ke liye array ke andar ya one-past position tak movement array rules follow karta hai. One-past pointer se wahan element access nahi kar sakte.
C17 Suitable pointer context mein null pointer constant se null pointer represent kar sakte hain. Iska matlab yeh nahi ki null pointer ka har byte zero hona chahiye.
C23 C23 mein null pointer constant nullptr add hua; <stddef.h> uske distinct type ko nullptr_t naam deta hai. Pointer type mein convert karne par null pointer milta hai. Lifetime, bounds, alignment aur access ke rules abhi bhi apply hote hain.
Yeh public committee drafts hain; clause references se explanation verify kar sakte hain. N3096 ek C23 working draft hai.
Apne words mein samjhayein
p redirect karne ke baad bhi q ke through write karne se left kyun badalta hai?
Ek explanation se compare karein
q ke paas apni copied pointer value hai. p redirect karna q ko nayi value assign nahi karta.
Aage badhne se pehle
- Pointer object pointer value store karta hai aur target se separate hai.
- Pointer copy karne se relationship copy hota hai; target copy ya lifetime extend nahi hoti.
- Valid access ko right target, lifetime, range, type aur permissions chahiye.
In ideas ko alag rakhein
- Reassigning p / Writing through p
- p = &other p mein pointer value assign karta hai; *p = value current valid target mein write karta hai.
q ko p ki copy milne ke baad p redirect ho toh kya badlega, aur q se write karne par kya hoga?
Optional: bolkar samjhein ya note rakhein. Tayyar hon toh aage badh sakte hain.Apni understanding check karein
Optional hai. Answers save ya send nahi hote; chapter kabhi lock nahi hota.
Har choice ki explanation padhein
- q automatically naye p ko follow karta hai.
Assignment ne pointer value copy ki thi, p par ongoing dependency nahi banayi.
- q apni purani pointer value rakhta hai jab tak separately change na ho.
✓ Sahi reasoning. Pointer objects alag hain, chahe unki values same target refer karein.
- Purana target automatically free ho jaata hai.
Pointer redirect karna apne aap old target ki storage release nahi karta.
C17
Earlier edition ka quick reference
Existing section links aur saved passages ke liye retained. Connected learning sequence ke liye upar expanded explanation padhein.
Pointers arguably C ki signature feature hain — aur inke bugs ka sabse notorious source bhi.
Fundamentals
Address-of operator & ek variable ka memory address deta hai; dereference operator * us address par store value ko access karta hai:
int x = 10;
int *p = &x; /* p, x ka address hold karta hai */
*p = 20; /* ab x, 20 hai */
Pointer Arithmetic
Pointer arithmetic elements mein advance karti hai: int * par p + 1, sizeof(int) bytes aage jaata hai, universally fixed chaar bytes nahi. Original aur resulting pointers same array object ke andar ya uske end se ek position aage hone chahiye; one-past pointer dereference nahi kar sakte. Pointer subtraction bhi same array (ya uski one-past position) aur ptrdiff_t mein representable difference require karta hai. Valid index ke liye arr[i] ka matlab *(arr + i) hai.
Pointers aur Arrays
Zyadatar array expressions first element ke pointer mein convert hote hain, lekin array khud pointer nahi hai. Important exceptions: array par sizeof, unary &, aur array initialize karne wala string literal. Function ke andar adjusted array parameter pointer hai; isliye sizeof(parameter) pointer ka size deta hai. Jahan chahiye separate element count pass karein.
Multiple Indirection
int **pp = &p; pointer-to-pointer hai. Isse caller ka pointer change karne wala output parameter ya separately managed row pointers ka array represent ho sakta hai. True two-dimensional array int grid[3][4] normally row ke pointer int (*)[4] mein convert hota hai, int ** mein nahi; layouts aur pointer types alag hain.
void Pointers
void * kisi bhi object type ka converted pointer hold kar sakta hai. Object value access karne ke liye directly dereference nahi kar sakte; pehle appropriate object-pointer type mein convert karein. C mein conversion implicit ho sakti hai: <stdlib.h> include hone par int *p = malloc(sizeof *p); ko cast nahi chahiye. C object pointers aur function pointers ke beech conversions generally guarantee nahi karti; standard C void * par arithmetic allow nahi karti.
NULL, Dangling, aur Wild Pointers
- Null pointer kisi object ya function ke pointer ke equal nahi compare hota. Appropriate header ka
NULL(ya C23 kanullptr) use karein; all-zero bits ya hardware address zero ki guarantee nahi. Isko dereference karna undefined behavior hai. - Dangling pointer aise object ko refer karta hai jiski lifetime end ho gayi. C rules mein pointed-to object ki lifetime end hone par pointer value indeterminate ho jaati hai; stale value ko dereference, compare ya otherwise rely na karein.
freeke baad ek pointer koNULLassign karne se doosre aliases repair nahi hote. - Uninitialized automatic pointer (jise often wild pointer kehte hain) ki value indeterminate hoti hai, usable “random address” nahi. Read/use se pehle initialize karein. Explicit initializer ke bina static-storage pointers null pointers se initialize hote hain.
Yeh teeno un segmentation faults aur memory-corruption bugs ke common sources hain jo careful pointer discipline ko reliable C programming ke liye essential banate hain.
Agla idea padhne ke liye tayyar?
Mark this chapter as read whenever you feel ready.