Dynamic memory — malloc, calloc, realloc, free: Question bank

5.1.14 · D5 · Coding › C Programming › Dynamic memory — malloc, calloc, realloc, free

True or false — justify karo

malloc us memory ko zero se initialize karta hai jo woh return karta hai.

False. malloc uninitialized (garbage) bytes return karta hai; sirf calloc hi zeros guarantee karta hai. Fresh pages OS ki luck se zeroed lag sakti hain, lekin reused heap memory mein purani contents hoti hain.

free(p) ke baad, variable p automatically NULL ban jaata hai.

False. free block ko allocator ko wapas karta hai lekin tumhare pointer variable ko bilkul touch nahi karta; p abhi bhi usi (ab dangling) address ko hold karta hai. Tumhe khud p = NULL; set karna hoga.

free(NULL) ek khatarnak galti hai jo crash kar sakti hai.

False. free(NULL) ko C standard explicitly ek harmless no-op ki tarah define karta hai, aur yahi wajah hai ki pointer ko free karne ke baad null karne se accidental second free safe ho jaata hai.

C standard guarantee karta hai ki calloc NULL return karega agar count * size overflow ho jaaye.

False. calloc mein overflow checking implementation-defined hai. Glibc, musl, etc. practice mein check karte hain, lekin ek conforming minimal libc ko yeh zaroori nahi — isliye isse bonus maano, portable guarantee nahi.

realloc(NULL, n) undefined behavior hai.

False. realloc(NULL, n) exactly malloc(n) ki tarah behave karne ke liye defined hai. Isse tum generic grow-loops likh sakte ho jo pehle call par bhi kaam karte hain jab pointer abhi bhi NULL ho.

realloc(p, 0) p ko free karta hai aur reliably NULL return karta hai.

False (subtle). Yeh p ko free kar sakta hai, lekin yeh NULL return kare ya ek chhota valid pointer — yeh implementation-defined hai. Return value ko "freed" ka matlab samajhne ki galti mat karo — freeing ke liye free use karo.

Heap par allocate ki gayi memory automatically reclaim ho jaati hai jab ek function return karta hai.

False. Sirf stack (automatic) variables function return par gaayab hote hain. Heap blocks tab tak rehte hain jab tak tum unhe free nahi karte ya program exit nahi karta — dekho The Stack and the Heap.

Agar malloc fail ho jaaye toh woh ek non-null lekin invalid pointer return karta hai.

False. malloc fail hone par exactly NULL return karta hai; koi "invalid non-null" sentinel nahi hota. Isliye ek single if (p == NULL) check kaafi hai.

sizeof(*p) aur sizeof(p) ek hi value compute karte hain.

False. sizeof(*p) us object ka size hai jis par p point karta hai (ek element); sizeof(p) pointer khud ka size hai (typically 64-bit par 8 bytes). Inhe confuse karne se under-allocation hoti hai — dekho sizeof operator.

Buffer ko har baar ek slot badhaana utna hi efficient hai jitna double karna.

False. Ek-ek add karne se har push par almost copy hoti hai, jo

O (n^{2})

total work deta hai. Doubling

O (n)

amortized work deta hai kyunki copies geometrically rare ho jaati hain.

Error dhundo

int *p = malloc(n); for(i=0;i<n;i++) p[i]=i;

Under-allocation. Tumne n bytes maange lekin n ints store kar rahe ho — tumhe n * sizeof(*p) bytes chahiye. Block ke baad likhna buffer overflow aur Undefined Behavior in C hai.

int *p = malloc(n*sizeof(*p)); if(p) { ... } free(p); free(p);

Double free. Doosra free(p) allocator ki bookkeeping corrupt karta hai. Fix: free(p); p = NULL; taaki repeat call harmless free(NULL) ban jaaye.

v = realloc(v, cap*sizeof(*v));

Self-assign leak. Agar realloc fail ho toh woh NULL return karta hai lekin old block alive rehta hai — tumne abhi iska ek-maatra pointer overwrite kar diya, usse leak kar ke. Ek temporary use karo aur sirf success par commit karo.

char *s = malloc(strlen(t)); strcpy(s, t);

Off-by-one. strlen terminating '\0' ko exclude karta hai, isliye copy block ke ek byte baad tak likhti hai. Tumhe strlen(t) + 1 chahiye.

int *p = malloc(n*sizeof(*p)); if(p==NULL); return -1; use(p);

Stray semicolon. if ki body empty hai, isliye return -1 unconditionally run karta hai — aur agar semicolon hatao bhi toh free se pehle return karke leak hoga. Logic aur cleanup dono broken hain.

free(a); a[0] = 5;

Use-after-free. free ke baad, block pehle se kisi doosre allocation ko reissue ho sakta hai; uspe likhna Undefined Behavior in C hai chahe pointer bits unchanged lagte hon.

int *p = calloc(-1, sizeof(*p));

Negative count wrap karta hai. calloc ke parameters size_t (unsigned) hain, isliye -1 ek bahut bada value ban jaata hai; call almost certainly NULL return karta hai, aur agar null check skip karo toh pehle use par crash hoga.

static int *g; void f(){ g = malloc(10*sizeof(*g)); } do baar call hua, koi free nahi.

Leak. Doosra call g ko overwrite karta hai, pehle block ka ek-maatra pointer bina free ke drop kar ke — yeh ek classic leak hai jo Memory Leaks and Valgrind flag karega.

Why questions

malloc(n*sizeof(*p)) kyun likhte hain malloc(n*sizeof(int)) ki jagah?

Kyunki sizeof(*p) automatically p ke type ko track karta hai. Agar baad mein p ko int* se long* mein change karo, toh yeh line bina kisi edit ke sahi rehti hai — yeh bugs ki ek poori class remove kar deta hai.

malloc ki return value check karna har baar zaroori kyun hai?

Heap exhausted ho sakti hai, jisme malloc NULL return karta hai; NULL dereference karna undefined behavior hai aur typically crash hota hai. Check karna ek silent disaster ko ek controlled failure path mein badal deta hai.

calloc ek product ki jagah do arguments kyun leta hai?

Yeh size ko count aur size mein todta hai taaki library khud multiplication kare — use ek chance deta hai us product ke overflow ko detect karne ka aur NULL return karne ka (zyaadar par, sabhi nahi, implementations mein).

realloc ke saath temporary variable kyun use karte hain?

Failure par realloc NULL return karta hai lekin old block abhi valid hai. Pehle tmp mein assign karne se original pointer preserve hota hai taaki tum use cleanly free kar sako instead of leak karne ke.

Pointer ko free karne ke baad turant NULL kyun set karte hain?

Ek freed pointer dangling hota hai — woh reclaimed memory ki taraf point karta hai. Use null karna accidental reuse ko silent corruption ki jagah clean crash banata hai, aur koi bhi repeat free ko safe no-op banata hai.

Stack runtime-sized data ke liye heap ko replace kyun nahi kar sakti?

Stack frames compile/scope boundaries par automatically size aur free hote hain aur inki limited size hoti hai; heap tumhe woh memory deta hai jiska amount aur lifetime tum runtime par control karte ho — yeh poora point hai Arrays vs Pointers ke mutabiq.

Capacity double karna fixed amount se grow karne se better kyun hai?

Har copy ki cost current length hoti hai, lekin doubling

n

pushes mein sirf

O (lo g n)

baar copies hoti hain, isliye total copy work

O (n)

amortized sum hota hai

O (n^{2})

ki jagah.

Edge cases

malloc(0) kya return karta hai?

Implementation-defined: ya toh NULL ya ek unique non-null pointer jo tum dereference nahi kar sakte lekin free zaroor karna hai. Kabhi assume mat karo ki yeh non-null aur usable hai.

Kya hota hai agar tum ek stack se aaye pointer ko free karo (jaise &x)?

Undefined behavior — free sirf woh pointer receive kar sakta hai jo malloc/calloc/realloc ne return kiya ho (ya NULL). Kuch aur dena allocator ko corrupt karta hai.

Kya free(p + 1) valid hai agar p ek valid malloc result tha?

Nahi. Tumhe exactly wahi pointer free karna hai jo allocator ne diya tha, interior ya offset pointer nahi. Shifted address free karna undefined behavior hai.

Agar realloc block move kar de, toh kya purane pointers us par abhi bhi valid hain?

Nahi. Jab realloc data relocate karta hai, toh purane block mein pehle se save har pointer (aur address ke roop mein cached index) dangling ho jaata hai. Sirf naaya return kiya hua pointer baad mein valid hota hai.

Kya program exit se pehle free bhoolna ek aisi leak cause karta hai jo matter karti hai?

Technically OS process exit par saari memory reclaim kar leta hai, isliye ek one-shot leak harmless hai — lekin long-running ya looping code mein yeh accumulate hoti hai aur ek real bug hai jo Memory Leaks and Valgrind report karega.

Kya tum ek pointer ko chhote size mein realloc kar sakte ho, aur kya surviving data safe hai?

Haan. Shrinking allowed hai; pehle n bytes preserve rehte hain aur tail release ho jaati hai. Returned pointer alag ho sakta hai, isliye phir bhi temporary ke zariye ise assign karo.