Mushkil ideas ko
saaf samjhein.
Aasani se mix hone wale ideas ke liye chhe focused guides. Compare karein, chhota example follow karein aur zaroorat par deeper rules kholein.
Ek idea se shuru karein. Koi score ya required order nahi hai. Yeh guides unke chapters ke andar bhi available hain.
01PointersPointer, uski value aur uska targetPointer object ko us object se alag samjhein jahan woh pahunchne deta hai.
Pointer, uski value aur uska target
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.
02ArraysArray ek object hai, pointer variable nahiArray, uske first element aur expression se milne wale pointer ko alag samjhein.
Array ek object hai, pointer variable nahi
Ek array instance mein ek type ke fixed number of elements hote hain. Bahut se expressions mein uska naam first element ke pointer mein convert hota hai. Is conversion se array object, pointer object nahi ban jaata.
Yeh kab kaam aata hai Actual array ka element count nikaalte waqt, array data function ko dete waqt aur subscript check karte waqt yeh difference kaam aata hai.
Ideas ko saath rakhkar padhein
- Array marks
- marks ka type array of 3 int hai. Uske storage mein teen int elements hain.
- Pointer p
- p ka type pointer to int hai. Use doosri pointer value assign kar sakte hain.
Array expression aksar pointer deta hai, lekin dono types alag hain.
- sizeof marks
- Is actual non-VLA array ke saare teen elements ka storage measure hota hai.
- sizeof p
- Pointer object measure hota hai, usse reachable storage nahi.
Element-count formula ke liye actual array chahiye, pointer parameter nahi.
- marks + 2
- Last element ko point karta hai. Array alive ho to ise access kar sakte hain.
- marks + 3
- One-past position hai. End mark kar sakti hai, par wahan read karne ke liye element nahi.
Legal pointer position hamesha legal dereference position nahi hoti.
Reasoning ko follow karein
Example mein ek function ke andar actual three-element array hai. size_t ke liye <stddef.h> available hai.
C17 · diye gaye context ke illustrative fragments
int marks[3] = {3, 6, 9};size_t count = sizeof marks / sizeof marks[0];int *p = marks;int last = *(p + 2);int *end = marks + count;
- Array initialize karein
marks[0], marks[1] aur marks[2] mein 3, 6 aur 9 hain.
- Element count nikaalein
sizeof marks, sizeof marks[0] ka teen guna hai; quotient 3 milta hai. int ka fixed byte size assume nahi karna padta.
- p initialize karein
Is initializer mein marks apne first element ke pointer mein convert hota hai. p yeh value store karta hai.
- Last element access karein
p + 2, marks[2] ko point karta hai. Dereference karne par 9 milta hai.
- End position banayein
marks + count array ke one-past hai. Example is pointer ko banata aur compare karta hai; dereference nahi karta.
Common misconceptions
Yeh statements misleading hain. Kyun, yeh samajhne ke liye har statement kholein.
MisconceptionArray ka naam ek pointer variable hai.
Array ka naam array object ko designate karta hai. Bahut se uses mein expression pointer value mein convert hota hai, par marks = p se array ko reassign nahi kar sakte.
MisconceptionFunction parameter int a[3] se teen elements ki copy pass hoti hai.
Array parameter declaration pointer parameter mein adjust hoti hai. Normal [3] spelling teen elements copy nahi karti aur count automatically saath nahi laati.
MisconceptionPaas mein memory hone se out-of-range subscript valid hai.
Access ko array bounds satisfy karne hote hain. Paas ka address ya successful run ek extra element nahi banata.
Thoda aur depth meinOptional technical detail
Operator ko dekhein
Yahan actual array par sizeof aur unary & usual array-to-pointer conversion apply nahi karte. &marks ka type pointer-to-array hai; p ke initializer mein marks se pointer-to-int milta hai.
Arrays of arrays mein row type bachta hai
int grid[2][3] ka usual conversion, 3 int ki row ke pointer mein hota hai. int ** nahi milta. Model mein row bounds aur pointed-to type ko saath rakhein.
C17 C17 mein array parameter adjustment aur one-past boundary apply hote hain. Variable-length arrays ke extra rules hain; yeh fixed-size example un par depend nahi karta.
C23 C23 ke typeof operators usual conversion ke bajay array type preserve kar sakte hain. Array parameters abhi bhi pointer parameters mein adjust hote hain; aise parameter par typeof ko adjusted type milta hai.
Yeh public committee drafts hain; clause references se explanation verify kar sakte hain. N3096 ek C23 working draft hai.
Apne words mein samjhayein
sizeof wala element-count formula yahan kyun kaam karta hai, pointer parameter par kyun nahi?
Ek explanation se compare karein
Yahan marks actual array hai. Pointer parameter ka type pointer hai, isliye sizeof caller ke array ke bajay us pointer ko measure karta hai.
03Scope aur lifetimeNaam kahan visible hai aur object kab exist karta haiScope, lifetime aur storage duration ko mental model mein alag rakhein.
Naam kahan visible hai aur object kab exist karta hai
Scope batata hai source code mein identifier kahan use ho sakta hai. Lifetime execution ke dauran object ke exist karne ka time batata hai. Storage duration us lifetime ko determine karne wale rules deta hai.
Yeh kab kaam aata hai Blocks, local static objects, recursion aur function se bahar jaane wale pointers padhte waqt yeh questions poochhein.
Ideas ko saath rakhkar padhein
- Scope
- Source code ka region jahan particular naam apni declared entity ko refer kar sakta hai.
- Lifetime
- Execution ka time jisme object exist karta hai aur uska storage reserved hai.
Naam hidden hone ka matlab zaroori nahi ki object dead hai.
- Automatic local fresh
- Yahan har active call ka naya object hota hai. Initializer tak pahunchne par 0 store hota hai.
- Static local total
- Ek object poore program tak rehta hai aur calls ke beech apni value rakhta hai.
Dono names ka block scope hai; objects ki storage duration alag hai.
- Naam aur initializer
- fresh ka scope source mein uske declarator ke turant baad shuru hota hai. Execution jab bhi declaration tak pahunchta hai, uska automatic initializer chalta hai.
- Block mein enter karna
- Ordinary non-VLA automatic object ki lifetime associated block mein entry par shuru hoti hai.
Name visibility, lifetime start aur initialization ko ek event na samjhein.
Reasoning ko follow karein
Alag statements mein visit ko do baar call karein. Return number mein total tens position aur fresh units position par hai.
C17 · diye gaye context ke illustrative fragments
int visit(void) {static int total;int fresh = 0;++total;++fresh;return total * 10 + fresh;}
- Calls se pehle
Static object total pehle se exist karta hai aur program startup se pehle zero-initialized hai. Uska naam sirf declared block mein visible hai.
- First call shuru karein
Is call ka apna automatic fresh object hai. Declaration tak pahunchne par initializer 0 store karta hai.
- Increment aur return
total 1 aur fresh 1 hota hai. Function 11 return karta hai; block chhodne par us call ke fresh ki lifetime khatam hoti hai.
- Second call shuru karein
Wahi total object abhi bhi 1 rakhta hai. Is call ka naya fresh object 0 se initialize hota hai.
- Dobara increment karein
total 2 aur naya fresh 1 hota hai. Second result 21 hai. Yahan dono automatic objects ko ek saath exist karna zaroori nahi.
Common misconceptions
Yeh statements misleading hain. Kyun, yeh samajhne ke liye har statement kholein.
MisconceptionHar local object declaration line execute hone par banta hai.
Ordinary non-VLA automatic objects ki lifetime block entry par shuru hoti hai; declaration baad mein naam introduce aur initialization kar sakti hai. VLAs ke lifetime rules alag hain.
MisconceptionLocal static object har call mein dobara banta hai.
Naam ka scope local hai, par object ki storage duration static hai. Is C example ki initialization C++ jaisa first-call operation nahi hai.
MisconceptionPointer return karne se local object ki lifetime badh jaati hai.
Pointer value return karne se target object ki lifetime extend nahi hoti. Ordinary local object ko uska function return hone ke baad access na karein.
Thoda aur depth meinOptional technical detail
Scope identifiers ke baare mein hai
Object ka apna naam out of scope ho, tab bhi valid pointer se us tak pahunch sakte hain. Us object ki lifetime ko alag se access permit karna chahiye.
Model ko machine ki promise na banayein
“Stack local” useful implementation vocabulary hai, C mein automatic storage duration ki definition nahi. C in objects ke liye ek physical stack layout mandate nahi karta.
C17 Walkthrough mein ordinary automatic int objects aur ek zero-initialized static int hai. VLAs, longjmp, threads aur compound-literal lifetime details is example mein nahi hain.
C23 C23 mein bhi scope aur lifetime ka difference apply hota hai. Naya syntax expired automatic object ke pointer ko valid nahi banata.
Yeh public committee drafts hain; clause references se explanation verify kar sakte hain. N3096 ek C23 working draft hai.
Apne words mein samjhayein
Second call mein fresh phir 0 kyun hota hai, jabki total 1 rakhta hai?
Ek explanation se compare karein
Second call ka naya automatic fresh object hai, jiska initializer 0 store karta hai. Static total object calls ke beech exist karta rehta hai.
04Integer conversionsDestination se pehle expression ka type dekheinPehle operand types, phir operation aur aakhir mein result ki conversion follow karein.
Destination se pehle expression ka type dekhein
C operation se pehle values convert kar sakta hai, aur result store karte waqt phir conversion ho sakti hai. Destination type peeche jaakar pehle wala operation nahi badalta.
Yeh kab kaam aata hai Integer division, mixed signed/unsigned comparisons, casts aur smaller type mein assignment padhte waqt yeh order use karein.
Ideas ko saath rakhkar padhein
- Integer division
- Divisor nonzero aur quotient representable ho, to int division se int result milta hai; fractional part zero ki taraf discard hota hai.
- Floating division
- Floating operand ki wajah se doosra arithmetic operand division se pehle convert ho sakta hai.
Sirf double destination hone se 5 / 2 floating operation nahi banta.
- Implicit conversion
- Operation, call, return ya assignment par language rules conversion request karte hain.
- Explicit cast
- Source mein named type ki conversion explicitly request hoti hai.
Explicit conversion bhi rules follow karti hai aur information lose kar sakti hai.
- Integer promotion
- Bahut se operations se pehle kuch integer types int ya unsigned int mein convert hote hain.
- Usual arithmetic conversions
- In rules ko use karne wale operators mein applicable promotions ke baad common arithmetic type milta hai.
“Bada dikhne wala variable jeetega” rule nahi hai.
Reasoning ko follow karein
Sirf dikhaye gaye do int operands use karein. Is walkthrough mein ordinary binary double arithmetic assume ki gayi hai, jahan 2.5 exactly representable hai.
C17 · diye gaye context ke illustrative fragments
int numerator = 5, denominator = 2;double first = numerator / denominator;double second = (double)numerator / denominator;
- Operand declarations padhein
numerator aur denominator int objects hain, jinmein 5 aur 2 hain.
- First division evaluate karein
Dono operands int hain, isliye numerator / denominator se int value 2 milti hai.
- first initialize karein
Pehle se computed 2, double mein convert hota hai. first ko 2.0 milta hai; lost fraction wapas nahi aata.
- Second division se pehle convert karein
(double)numerator se 5.0 milta hai. Is division mein denominator bhi double mein convert hota hai.
- second initialize karein
Floating division se 2.5 milta hai aur second initialize hota hai. Cast ki position se operation badalta hai.
Common misconceptions
Yeh statements misleading hain. Kyun, yeh samajhne ke liye har statement kholein.
MisconceptionLeft-hand type poori right side ki calculation decide karta hai.
Pehle right-hand expression ko uske operand types se evaluate karein. Phir destination ke liye zaroori conversion apply hoti hai.
MisconceptionCast prove karta hai ki value fit hogi.
Cast conversion request karta hai; aapke liye range check nahi karta. Value preserve karni ho to conversion se pehle relevant limits check karein.
MisconceptionUnsigned se arithmetic hamesha safer hoti hai.
Unsigned arithmetic ke wraparound rules hain, par wrapped count logically galat ho sakta hai. Mixed signed/unsigned operations comparison ka meaning bhi badal sakte hain.
Thoda aur depth meinOptional technical detail
Same rank ke signed aur unsigned
Usual arithmetic conversion mein int aur unsigned int ka common type unsigned int hai. -1 < 1U mein -1, UINT_MAX banta hai aur comparison false hota hai. Original int object modify nahi hota.
Conversion aur signed overflow alag hain
Integer ko unsigned type mein convert karne par modular reduction hoti hai. Out-of-range integer-to-signed conversion ka result ya signal implementation-defined hota hai. Signed arithmetic overflow ka alag rule hai: undefined behavior.
C17 Examples standard int, unsigned int aur double ke rules use karte hain. Doosri jagah inhe apply karte waqt 8-bit byte ya 32-bit int assume na karein.
C23 C23 signed integers ke liye two’s-complement representation require karta hai, par signed overflow abhi bhi undefined hai. Out-of-range integer-to-signed conversion implementation-defined rehti hai ya implementation-defined signal aa sakta hai. _BitInt ke extra promotion rules is guide ke scope se bahar hain.
Yeh public committee drafts hain; clause references se explanation verify kar sakte hain. N3096 ek C23 working draft hai.
Apne words mein samjhayein
Completed integer quotient ko double cast karna 2.5 laane ke liye der se kyun hota hai?
Ek explanation se compare karein
Integer division pehle hi 2 produce kar chuka hai. Baad ki conversion wahi value preserve karti hai; floating operands se division dobara nahi hota.
05Function callsCall alag execution ko values deta haiArgument, parameter aur pointer se reachable object ko follow karein.
Call alag execution ko values deta hai
Suitable prototype wale function mein argument values parameter types mein convert hoti hain. Har call ke parameters alag objects hain. Copied pointer value abhi bhi caller ke object ko designate kar sakti hai.
Yeh kab kaam aata hai Output parameters, independent recursive calls aur parameter badalne versus target badalne ka difference samajhne ke liye yeh model use karein.
Ideas ko saath rakhkar padhein
- Argument
- Call par diya expression, jaise score ya &score.
- Parameter
- Us call ke function body mein use hone wala named object, jaise value ya target.
Parameter caller ke variable se automatically bound doosra naam nahi hai.
- Copied int ko badalna
- value = 9 se parameter object value badalta hai.
- Copied pointer se write karna
- *target = 9 se copied pointer ke designated live int object mein change hota hai.
Dono calls mein C ek value hi pass karta hai.
- Function declaration
- Function introduce hota hai; prototype ho to parameter types describe hoti hain.
- Function definition
- Saath mein woh body bhi milti hai jo function call par execute hoti hai.
Jahan body required hai, use dena hota hai; declaration akele implementation nahi deta.
Reasoning ko follow karein
Neeche pointer call ko &score milta hai, isliye target valid live int hai. Function arbitrary pointers ko validate karne wala general checker nahi hai.
C17 · diye gaye context ke illustrative fragments
void change_copy(int value) { value = 9; (void)value; }void change_target(int *target) { *target = 9; }/* inside a caller: */int score = 4;change_copy(score);change_target(&score);
- Caller ka object initialize karein
score int object hai, jiski value 4 hai.
- change_copy call karein
Value 4 uske int parameter ko pass hoti hai. Alag parameter ko 9 assign karne se score assign nahi hota.
- First call se return karein
Parameter ki lifetime khatam hoti hai. score abhi bhi 4 rakhta hai.
- change_target call karein
&score ek pointer value deta hai. Parameter target ko yeh value milti hai aur woh score ko designate karta hai.
- target ke through write karein
*target = 9 se score badalta hai. Return par pointer parameter ki lifetime khatam hoti hai, caller ke score object ki nahi.
Common misconceptions
Yeh statements misleading hain. Kyun, yeh samajhne ke liye har statement kholein.
MisconceptionPointer pass karne par C pass-by-reference mode mein aa jaata hai.
Pointer value by value pass hoti hai. Suitable target tak indirect access milta hai, par parameter alag pointer object hi rehta hai.
MisconceptionRecursive call previous call ke parameters overwrite karta hai.
Har active call ke apne automatic parameter objects hote hain. Agar shared static object use kiya hai to woh alag issue hai.
MisconceptionFunction arguments hamesha left to right evaluate hote hain.
C generally unka evaluation order specify nahi karta. Kisi order par depend na karein, khaaskar jab arguments same object ko read aur modify karte hain.
Thoda aur depth meinOptional technical detail
Array parameter spelling array copy nahi karti
Array ke roop mein declared parameter pointer parameter mein adjust hota hai. Zaroori count separately pass karein ya clear size contract wala interface use karein.
Macros alag kaam karte hain
Function-like macro preprocessing tokens substitute karta hai. Parameter objects ya function-call boundary nahi banti. Parentheses grouping fix kar sakte hain, par repeated evaluation abhi bhi possible hai.
C17 C17 mein int f(); jaisi declaration parameter-type prototype nahi deti. int f(void); explicitly no parameters declare karta hai. Is guide ke calls prototypes use karte hain.
C23 C23 mein int f(); ki empty parameter list no parameters specify karti hai aur prototype deti hai. Is change se function arguments left to right evaluate nahi hone lagte.
Yeh public committee drafts hain; clause references se explanation verify kar sakte hain. N3096 ek C23 working draft hai.
Apne words mein samjhayein
target copy hai, to *target se score kaise badalta hai?
Ek explanation se compare karein
Copied pointer value abhi bhi score ko designate karti hai. target ko khud badalna aur *target se write karna alag operations hain.
06Undefined behaviorValid explanation ke liye operation bhi valid hona chahiyeLanguage guarantee, documented choice aur C se undefined operation ko alag samjhein.
Valid explanation ke liye operation bhi valid hona chahiye
Undefined behavior mein us situation ke liye C standard koi requirements impose nahi karta. Iska matlab surprising output guess karna nahi hai. Pehle poochhein ki har evaluated operation apna contract satisfy karta hai ya nahi.
Yeh kab kaam aata hai Bounds, expired objects, arithmetic limits aur interacting side effects wale expressions trace karne se pehle yeh habit use karein.
Ideas ko saath rakhkar padhein
- Unspecified behavior
- Standard alternatives allow karta hai; implementation ko chosen alternative document karna required nahi.
- Implementation-defined behavior
- Allowed choice ko implementation document karta hai.
Dono ki language-defined boundaries hain; dono ka matlab har possible outcome nahi.
- Undefined behavior
- Affected situation par standard koi requirements impose nahi karta.
- Constraint violation
- Translation unit mein constraint violate hoti hai. Conforming implementation ko us unit ke liye kam se kam ek diagnostic dena hota hai.
Diagnostic ka matlab compile karne se refusal zaroori nahi; har undefined operation par diagnostic required nahi.
- Successful observed run
- Ek build aur environment mein ek run ka observation hai.
- Language guarantee
- Stated C rules aur preconditions ke under apply hoti hai.
Sirf observation se program ka defined behavior prove nahi hota.
Reasoning ko follow karein
Subscripted read se pehle bounds check karein. Example jaanboojhkar one-past index choose karke safe alternative leta hai.
C17 · diye gaye context ke illustrative fragments
int values[3] = {3, 6, 9};size_t index = 3;if (index < 3) {/* values[index] may be read here */} else {/* handle the missing element */}
- Valid indexes samjhein
Three-element array ke indexes 0, 1 aur 2 hain.
- index ki value padhein
index mein 3 hai. Sirf is integer value ko rakhna invalid array access nahi hai.
- Guard evaluate karein
index < 3 false hai. Abhi tak koi element read karne ke liye array subscript evaluate nahi hua.
- Element access skip karein
Guarded branch execute nahi hoti. Program values[3] read nahi karta.
- Missing element handle karein
else branch no element report karti hai. Out-of-range read par depend karne ke bajay is case ko defined behavior milta hai.
Common misconceptions
Yeh statements misleading hain. Kyun, yeh samajhne ke liye har statement kholein.
MisconceptionUndefined behavior mein program usi line par crash karega.
Standard kisi specific symptom ya failure point ka promise nahi karta. Build kaam karta dikh sakta hai, fail ho sakta hai ya optimization ke baad alag behave kar sakta hai.
MisconceptionTwo’s complement signed wraparound guarantee karta hai.
Representation rule overflowing signed arithmetic define nahi karta. Signed result type ki range ke bahar ja sakta ho to compute karne se pehle check karein.
MisconceptionSanitizer prove karta hai ki poore program mein undefined behavior nahi.
Sanitizer executed paths par supported conditions check karta hai. Tests aur diagnostics madad karte hain, par har path aur language rule cover nahi karte.
Thoda aur depth meinOptional technical detail
Precedence evaluation order establish nahi karta
Parentheses expression ko group karte hain. Woh generally operands ko sequence nahi karte. i++ + i++ ko unsequenced side-effect conflict ke roop mein analyze karein; portable answer dhoondhne ke liye run na karein.
Invalid operation rokein, sirf visible result nahi
Guard ko dangerous access ya arithmetic se pehle evaluate hona chahiye. Pehle values[index] read karke baad mein index check karna boundary cross kar chuka hai.
C17 Yeh bounds aur sequencing rules C17 baseline par apply hote hain. Runtime undefined behavior aur translation-time constraint diagnostics ka difference rakhein.
C23 C23 out-of-bounds reads, expired objects ka access ya unsequenced modifications ko safe nahi banata. Two’s-complement representation se signed arithmetic overflow defined nahi hota.
Yeh public committee drafts hain; clause references se explanation verify kar sakte hain. N3096 ek C23 working draft hai.
Apne words mein samjhayein
Is three-element array ke liye sirf index = 3 store karna undefined hai?
Ek explanation se compare karein
Nahi. Integer value store aur test kar sakte hain. Guarded example invalid element access avoid karta hai, isliye us value ko safely handle kar sakta hai.