Memory mistakes ko samjhein
Crash guess karne ke bajay lifetime, bounds, type, initialization aur ownership se invalid access samjhein.
Is chapter mein9 sections
Pointer dekhne mein theek lag sakta hai, phir bhi operation ke liye invalid ho sakta hai. Memory mistakes aksar boundary cross karne, lifetime ke baad object use karne ya ownership bhoolne se hoti hain. Har failure ko uske broken rule se jodenge.
1. Valid access ko multiple facts saath chahiye
| Question | Kya establish karein |
|---|---|
| Kaunsa object? | Pointer ya expression intended object designate karti hai. |
| Alive hai? | Uski lifetime shuru hui hai aur end nahi hui. |
| Range mein? | Operation permitted array ya object bounds mein hai. |
| Suitable access? | Alignment, effective type, initialization aur mutability rules follow ho rahe hain. |
| Release kaun karega? | Allocation ka consistent ownership aur cleanup contract hai. |
Yeh questions ek-doosre ko complement karte hain. Null check target ke alive ya in-range hone ka proof nahi. Sufficiently large allocation se yeh prove nahi hota ki bytes read kiye gaye type ki initialized value represent karti hain. Cast ended lifetime restart nahi karta. Ek input ka successful test har execution ke saare preconditions establish nahi karta.
2. Invalid access banane se pehle bound check karein
int values[3] = {4, 5, 6};
size_t count = sizeof values / sizeof values[0];
size_t index = 2;
int selected = 0;
if (index < count) {
selected = values[index];
}
Check subscripting se pehle hai. Pointer arithmetic mein bhi out-of-range pointer banane se pehle reasoning karein. Array ke bahar write karke later condition ko safety ka evidence na samjhein. Nonempty array ka last element index count minus one hai; one-past pointer boundary represent karta hai, spare storage nahi.
Off-by-one errors often capacity ko last index, ya string length ko required storage samajhne se aati hain. Length three ki string ko terminator ke liye fourth element chahiye. Three-integer array mein fourth integer sirf isliye nahi hota ki machine par neighboring memory address ki ja sakti hai.
3. Stale alias second chance nahi
int *owner = malloc(sizeof *owner);
if (owner == NULL) {
return EXIT_FAILURE;
}
int *borrowed = owner;
*borrowed = 9;
int saved_value = *borrowed;
free(owner);
owner = NULL;
borrowed = NULL;
Object alive hote waqt value copy hui. free ke baad koi old pointer value read nahi hoti; har pointer object ko fresh null value assign hoti hai. Sirf owner null karne se borrowed automatically change nahi hota. Real interfaces ko outstanding borrowers ka ended object access prevent karna hoga; sirf owner variable reset karne par rely nahi karna chahiye.
Release ke baad allocation use karna use-after-free hai. Usko dobara release karna double free hai. C kisi ke liye particular error message promise nahi karti. Successful realloc old allocation ke pointers retire karta hai, chahe returned pointer ka apparent address same ho. Replacement se pehle needed data ya offsets retain karein, phir new result se valid access rebuild karein.
4. Result ko valid lifetime ke saath return karein
#include <assert.h>
static int make_score(void)
{
int local = 7;
return local;
}
int main(void)
{
int score = make_score();
assert(score == 7);
return 0;
}
Integer value return karne se local object ki lifetime end hone se pehle result copy hota hai. Ordinary local object ka address return karna usko alive nahi rakhega. Doosre choices hain: valid caller-provided object mein write karna, release contract ke saath owned allocation return karna, ya documented sharing behavior wala static object deliberately use karna. Pehle lifetime choose karein, phir pointer syntax.
5. Leaks unreleased responsibility ka issue hain
Allocation ki last usable reference lose karne se program ke liye release impossible ho sakti hai. Owning pointer ko failed realloc result se directly overwrite karna common example hai. Reachable allocations bhi useful lifetime policy ke bina retained rehkar leak bana sakti hain. Raw pointer ka present hona cleanup hone ka proof nahi.
Common hosted operating systems process terminate hone par resources reclaim karte hain, lekin woh universal C memory-management rule nahi aur termination se pehle long-running program ko help nahi karta. Allocation free karne se storage allocator ke liye reusable ho sakti hai bina process ki physical memory use immediately kam hue. Single “heap grows” picture ke bajay allocation lifetimes par reason karein.
6. Tools reasoning ko support karte hain
Compiler diagnostics suspicious conversions, missing declarations aur kuch invalid accesses expose kar sakte hain. Runtime memory instrumentation executed paths par kai errors find kar sakti hai. Clean run unexecuted path ko safe prove nahi karta. Kuch defects language rules violate karte hain chahe particular machine unko tolerate karti dikhe.
Empty input, one element, last valid element, maximum accepted sizes aur failure cleanup exercise karne wale small cases use karein. Deliberately invalid examples normal runnable code se bahar rakhein: violated rule explain karein aur undefined behavior ka specific output promise na karein. Is unit ke examples valid patterns dikhate hain; use-after-free ya out-of-bounds access ko guessing exercise ke roop mein execute nahi karte.
Primary references aur aage padhne ke liye
- WG14 N1570 — public C11 committee draft: 6.2.4p2, 6.5, 6.5.6, 7.22.3. Yeh stable rules C17 baseline ko support karte hain; yeh draft final ISO publication nahi hai.
Aage badhne se pehle
- Bounds, lifetime, type aur ownership failures different memory mistakes hain.
- Non-null pointer bhi requested access ke liye invalid ho sakta hai.
- Diagnostic tools exercised cases ka evidence dete hain; sab executions ka proof nahi.
In ideas ko alag rakhein
- Freeing one pointer / Repairing aliases
- Target release karna ya ek pointer clear karna doosre aliases ko repair nahi karta.
Small failing example mein buffer overrun aur use-after-free alag pehchaanne ke liye kya check karenge?
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
- Nahi. Doosre pointer objects automatically update nahi hote.
✓ Sahi reasoning. Ownership aur alias lifetimes ka contract chahiye; ek pointer clear karna sirf us pointer object ko badalta hai.
- Haan, free saare aliases dhoondhkar clear karta hai.
free allocated storage release karta hai; saare pointer objects dhoondhkar rewrite nahi karta.
- Haan, NULL wahi allocation dobara release karta hai.
NULL assign karna assignment hai, doosri deallocation operation nahi.
C17
Agla idea padhne ke liye tayyar?
Mark this chapter as read whenever you feel ready.