realloc() & free()
realloc(ptr, newSize) pehle se allocated memory ka size badha ya ghata sakta hai — purana data (jitna fit ho sake) preserve rehta hai. Ye internally memory ko naye jagah move bhi kar sakta hai agar current location mein itni jagah na ho — isliye hamesha realloc() ka return value use karo, purana pointer nahi.
free(ptr) heap memory ko wapas system ko de deta hai. Ek baar free() karne ke baad, us pointer ko use karna (dereference karna) undefined behavior hai — is bug ko "use-after-free" kehte hain, aur ye security vulnerabilities ka bhi common source hai.
free() karne ke baad pointer ko NULL set karna best practice hai — isse agar galti se dubara use ho bhi jaaye, program crash karega (NULL dereference) instead of silently corrupt data access karne ke.
int *arr = malloc(5 * sizeof(int));
// ... arr use karo ...
int *bigger = realloc(arr, 10 * sizeof(int)); // ab 10 ints ke liye jagah
if (bigger == NULL) {
// realloc fail — original 'arr' ab bhi valid hai
free(arr);
return 1;
}
arr = bigger; // hamesha naya pointer use karo
free(arr);
arr = NULL; // dangling pointer se bachao- realloc() = existing allocation resize karta hai, data preserve karta hai
- free() ke baad pointer use karna = "use-after-free" bug
- free() ke baad pointer ko NULL set karo — safety habit
realloc() ka sabse common real-world use ek "growable array" banana hai — jab initial size kam pad jaaye, capacity double karke realloc() kar dete hain. Ye pattern C++ ke std::vector aur Python list ke internal implementation jaisa hi hai.
int capacity = 2, count = 0;
int *arr = malloc(capacity * sizeof(int));
for (int i = 0; i < 5; i++) {
if (count == capacity) {
capacity *= 2; // double the capacity
int *temp = realloc(arr, capacity * sizeof(int));
if (temp == NULL) { free(arr); exit(1); }
arr = temp;
}
arr[count++] = i * 10;
}
free(arr);Ek hi pointer ko do baar free() karna ("double-free") undefined behavior hai — crash ho sakta hai ya, kai baar security vulnerability ban sakta hai. Isi tarah, free() karne ke baad us pointer ko use karna ("dangling pointer" / "use-after-free") bhi dangerous hai.
int *p = malloc(sizeof(int));
free(p);
// free(p); // DANGER: double-free — undefined behavior
// *p = 5; // DANGER: use-after-free
p = NULL; // ab safe hai — dubara free(NULL) ya check karna theek hai
if (p != NULL) {
free(p); // ye line kabhi nahi chalegi (p NULL hai)
}