Dynamic Memory (malloc/free)

Dynamic memory की ज़रूरत क्यों?

जब आप int a[100]; लिखते हैं, तो आपको size — 100 — code लिखते समय तय करना पड़ता है। पर अगर आपको program चलने तक पता ही न हो कि कितने items होंगे? शायद user तय करे। Size पहले से तय करना या तो memory बर्बाद करता है या जगह कम पड़ जाती है।

Dynamic memory allocation इसे हल करता है। यह आपके program को चलते समय ठीक उतनी memory माँगने देता है जितनी चाहिए, एक बड़े pool से जिसे heap कहते हैं। आपको उस memory का pointer मिलता है, उसे इस्तेमाल करें, और काम खत्म होने पर लौटा दें।

चार functions

ये <stdlib.h> में होते हैं:

malloc: block allocate

malloc कुल bytes लेता है जितने आप चाहते हैं। हम आमतौर पर sizeof से गुणा करते हैं ताकि हर system पर सही रहे।

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *arr = malloc(3 * sizeof(int));   // 3 ints की जगह
    if (arr == NULL) return 1;            // हमेशा जाँचें!

    arr[0] = 10; arr[1] = 20; arr[2] = 30;
    printf("%d %d %d\n", arr[0], arr[1], arr[2]);

    free(arr);                            // वापस दें
    return 0;
}

calloc: allocate और zero

calloc malloc जैसा है पर memory को 0 भी कर देता है, और यह count तथा element size अलग-अलग लेता है।

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *arr = calloc(3, sizeof(int));   // 3 ints, सब zero
    if (arr == NULL) return 1;

    printf("%d %d %d\n", arr[0], arr[1], arr[2]);  // 0 0 0
    free(arr);
    return 0;
}

malloc के साथ ये values garbage होतीं। जब साफ़, zero शुरुआत चाहिए तब calloc इस्तेमाल करें।

realloc: block resize

मान लीजिए आपने 3 ints की जगह ली पर अब 5 चाहिए। realloc block बड़ा करता है, पुरानी values रखते हुए।

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *arr = malloc(3 * sizeof(int));
    arr[0] = 1; arr[1] = 2; arr[2] = 3;

    arr = realloc(arr, 5 * sizeof(int));  // 5 तक बड़ा करें
    arr[3] = 4; arr[4] = 5;

    for (int i = 0; i < 5; i++) printf("%d ", arr[i]);
    free(arr);
    return 0;
}

free और memory leaks

हर block जो आप allocate करते हैं उसे free से छोड़ना होगा। अगर भूल गए, तो वह memory program खत्म होने तक आरक्षित रहती है — एक memory leak। घंटों चलने वाले program में leaks इकट्ठा होकर उसे crash कर सकते हैं।

int *p = malloc(sizeof(int));
*p = 42;
free(p);      // memory release करें
p = NULL;     // dangling pointer से बचें

आम गलतियाँ

• Memory इस्तेमाल करने से पहले यह न जाँचना कि malloc/calloc ने NULL तो नहीं लौटाया।
• free भूल जाना, जिससे memory leak होता है।
• Pointer को दो बार free करना, या free के बाद इस्तेमाल करना (dangling pointer)।
• बिना जाँचे p = realloc(p, ...) लिखकर original pointer खोना — realloc fail होने पर NULL लौटाता है और आप पुराना block खो देते हैं।

सारांश

• Dynamic memory program को चलते समय heap से memory माँगने देती है।
• malloc allocate करता है (garbage); calloc allocate करके zero करता है।
• realloc block resize करता है और हिला सकता है — उसका result दोबारा assign करें।
• हर allocation के लिए एक मेल खाता free चाहिए, वरना memory leak होता है।
• NULL जाँचें, और free के बाद pointers को NULL करें।