YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Memory aur dataChapter 29 of 73

Memory mistakes ko samjhein

Crash guess karne ke bajay lifetime, bounds, type, initialization aur ownership se invalid access samjhein.

6 min readFoundationsC17 baseline
Offline reading
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

QuestionKya 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

C17 · illustrative fragment
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

C17 · illustrative fragment
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

Complete C17 program
#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

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.
Apne words mein samjhaayein

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.

free ke baad ek pointer ko NULL dene se kya har alias repair ho jaata hai?
Har choice ki explanation padhein
  1. 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.

  2. Haan, free saare aliases dhoondhkar clear karta hai.

    free allocated storage release karta hai; saare pointer objects dhoondhkar rewrite nahi karta.

  3. 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.

CHAPTER 29 / 73

Is chapter mein

Memory mistakes ko samjhein

Search all 73 chapters in both languages.EN + HG

Try “pointer”, “why int”, or “undefined behavior”.

Concepts connect. Follow your curiosity.↑ ↓ to explore · Enter to open
MAKE YOURSELF COMFORTABLE

Your reading space

Appearance

A clear canvas with balanced contrast.

Text size

100%
AA

Reading tools

Your data stays in this browser

Export a backup before changing browsers or replacing an older version of the reader.

YOUR PERSONAL MARGINS

My notebook

Saved on this device
A LITTLE CLARITY

The glossary

A starting meaning, then a chapter to go deeper.

A QUICK DEFINITION

A little clarity

Read the full explanation →

A thought worth keeping