Dynamic memory — malloc, calloc, realloc, free

5.1.14 · Coding › C Programming

WHAT: Chaar functions

Sab <stdlib.h> mein declare hote hain. Yeh bytes mein kaam karte hain aur tumhe ek void * dete hain (ek generic address jo tum apne type mein cast karte ho).

WHY har ek exist karta hai (80/20 distinctions)

HOW: Sahi call ko first principles se derive karna

Tum kabhi memorize nahi karte "malloc ek number leta hai." Tum argument derive karte ho:

Formula Mujhe kitne bytes chahiye?

n objects of type T hold karne ke liye: $bytes = n \times sizeof(T)$ Toh canonical, type-safe call yeh hai:

T *p = malloc(n * sizeof(*p));   // sizeof(*p) == sizeof(T), type changes survive karta hai

sizeof(*p) kyun, sizeof(T) kyun nahi? Agar tum baad mein p ka type change karo, yeh line automatically correct rehti hai. Yeh steel-manned best practice hai.

Worked example Worked Example 1 —

n ints ka malloc array

#include <stdlib.h>
#include <stdio.h>
 
int n = 5;
int *a = malloc(n * sizeof(*a));   // Step 1
if (a == NULL) return 1;           // Step 2
for (int i = 0; i < n; i++)        // Step 3
    a[i] = i * i;
free(a);                           // Step 4
a = NULL;                          // Step 5

Step 1 — n * sizeof(*a) kyun? malloc ko bytes chahiye; n ints = n × 4 bytes (ek typical 32-bit-int machine par). sizeof(*a) humare liye per-element size compute karta hai.
Step 2 — NULL check kyun? Heap exhausted ho sakta hai. malloc failure par NULL return karta hai; isse use karna crash karega. Hamesha check karo.
Step 3 — Loop kyun? malloc garbage deta hai, toh padhne se pehle initialize karna zaroori hai.
Step 4 — free kyun? OS program run hote waqt heap memory automatically reclaim nahi karta. Isse bhoolna = memory leak.
Step 5 — a = NULL kyun? free ke baad, a ek dangling pointer hai (reclaimed memory point karta hai). Isse NULL set karne par accidental reuse ek clean crash hota hai, silent corruption nahi.

Worked example Worked Example 2 — Zeroed counters ke liye

calloc

int *count = calloc(26, sizeof(*count));  // 26 letter-frequency counters, sab 0
if (!count) return 1;
count['z' - 'a']++;                        // manual zeroing ki zaroorat nahi
free(count);

calloc yahan kyun? Ek frequency table ko zero se start karna hota hai. calloc yeh guarantee karta hai; malloc ke liye manual memset/loop karna padta.
Do args (26, sizeof) kyun? calloc tumhare liye 26 * sizeof(*count) multiplication karta hai. Zyaadaatar real implementations us product ka overflow bhi detect karte hain (NULL return karke), haalaanki woh check implementation-defined hai, standard se mandated nahi.

Worked example Worked Example 3 —

realloc se buffer grow karna

int cap = 2, len = 0;
int *v = malloc(cap * sizeof(*v));
for (int x = 0; x < 10; x++) {
    if (len == cap) {                       // Step A: full?
        cap *= 2;                            // Step B: capacity double karo
        int *tmp = realloc(v, cap * sizeof(*v));  // Step C: resize
        if (!tmp) { free(v); return 1; }     // Step D: safe-assign
        v = tmp;                             // Step E: commit
    }
    v[len++] = x;
}
free(v);

Step A — len aur cap alag kyun track karein? cap = allocated space; len = used space. Tum tabhi grow karte ho jab used, allocated tak pahunch jaaye.
Step B — Double (geometric growth) kyun? Doubling karne se n insertions ki total cost $O (n)$ amortized hoti hai, $O (n^{2})$ nahi. Har baar 1 add karne par har push par poora array copy hota.
Step C — realloc kaise kaam karta hai? Yeh block ko in-place extend kar sakta hai, ya naya block allocate karke tumhare purane bytes copy karke purana free karta hai — sab transparently.
Step D/E — tmp variable kyun? Agar realloc fail ho toh woh NULL return karta hai lekin purana block still valid hai. Seedha v = realloc(v, ...) likhne par NULL return hone par purana block leak ho jaata (uska address kho gaya).

Figure — Dynamic memory — malloc, calloc, realloc, free

Common mistakes (Steel-manned)

free actually kya free karta hai? Yeh block ko heap allocator ki free list mein reuse ke liye return karta hai — yeh bytes wipe nahi karta aur tumhara pointer variable change nahi karta.

Recall

malloc(n * sizeof(*p)) ko malloc(n * sizeof(int)) se kyun prefer karein? sizeof(*p) automatically p ka type track karta hai, toh agar type change ho toh line correct rehti hai — kam bug surface.

Recall Ek case batao jahan

calloc strictly better hai malloc se. Jab tumhe zero-initialized memory chahiye (counters/flags); zyaadaatar implementations mein yeh size ko count/size mein split karta hai aur multiplication overflow detect karta hai (haalaanki woh overflow check implementation-defined hai, standard-mandated nahi).

Recall Feynman: 12-saal ke bachche ko samjhao

Ek library socho. Ek normal array aise hai jaise aane se pehle fixed table book karna — tumhe guess karna padta hai kitne dost aayenge. Heap librarian jaisi hai: tum jaate ho aur kehte ho "mujhe 5 kursiyan chahiye" abhi (malloc). Agar kursi ganди thi toh tum khud saaf karo; agar tidy librarian (calloc) se maango toh woh saaf kursiyan deta hai. Baad mein aur kursiyan chahiye? realloc badi jagah dhundh ke tumhara saamaan le jaata hai. Jaate waqt, tumhe kursiyan wapas karni hain (free) varna koi aur use nahi kar sakta — yahi "leak" hai. Aur wapas karne ke baad, unpar baithna band karo (pointer mat use karo), varna kisi aur ki lap milegi!

Connections

Pointers in C — dynamic memory pointers return karta hai; tumhe void * aur casting samajhna hoga.
Arrays vs Pointers — a[i] malloc'd blocks par kaam karta hai pointer arithmetic ki wajah se.
The Stack and the Heap — automatic vs dynamic variables kahan rehte hain aur lifetimes kyun differ karti hain.
Memory Leaks and Valgrind — missing frees pakadne ke liye tooling.
sizeof operator — byte counts compute karne ka aadhar.
Undefined Behavior in C — use-after-free, double-free, out-of-bounds.

malloc/calloc/realloc/free kaunsa header declare karta hai?

<stdlib.h>

malloc se returned memory ka contents kya hota hai?

Uninitialized garbage (zeroed nahi)

calloc se returned memory ka contents kya hota hai?

Sab bytes zero set hoti hain

calloc(count, size) ke do arguments ka kya matlab hai?

elements ki sankhya aur har ek ka size; yeh count*size bytes allocate karta hai

Kya C standard guarantee karta hai ki calloc multiplication overflow detect kare?

Nahi — overflow handling implementation-defined hai; zyaadaatar real libcs check karke NULL return karte hain, lekin yeh standard-mandated nahi hai

malloc failure par kya return karta hai?

NULL

realloc kya preserve karta hai?

Purane block ka contents (chhote size tak, purana ya naya jo bhi chhota ho)

realloc ke saath temporary pointer kyun use karein?

Failure par woh NULL return karta hai lekin purana block rakhta hai; directly assign karne par purana block leak ho jaata

Dangling pointer kya hota hai?

Ek pointer jo already freed memory ka address hold karta hai

free(p) ke baad immediately kya karna chahiye?

p = NULL; set karo use-after-free aur double-free se bachne ke liye

Memory leak kya hota hai?

Allocated heap memory jo kabhi free nahi ki gayi aur jiska pointer kho gaya, toh reuse nahi ho sakti

Buffer grow karte waqt capacity double kyun karte hain?

Geometric growth se amortized O(n) total insertion cost milti hai O(n^2) ki jagah

malloc kaunsa type ka pointer return karta hai?

void *, C mein kisi bhi object pointer type mein implicitly convertible

Kya free(NULL) safe hai?

Haan, yeh ek defined no-op hai

malloc(n * sizeof(*p)) n elements ke liye kitne bytes request karta hai?

n × sizeof(*p) bytes