C भाषा में डायनामिक मेमोरी आवंटन का उदाहरण

समस्या

उपयोगकर्ता द्वारा दर्ज n संख्याओं का योग डायनामिक मेमोरी आवंटन से ज्ञात करना।

फंक्शन्स अवलोकन

• malloc() - बाइट्स में ब्लॉक आवंटित
• calloc() - सन्निहित शून्य-प्रारंभिकृत ब्लॉक
• realloc() - आकार बढ़ाएं/घटाएं
• free() - मेमोरी मुक्त करें

पूर्ण प्रोग्राम: योग और free() प्रदर्शन

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n, *arr, sum = 0;
    
    printf("तत्वों की संख्या: ");
    scanf("%d", &n);
    
    if (n <= 0) {
        printf("अमान्य संख्या\n");
        return 1;
    }
    
    // malloc से आवंटन
    arr = malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("मेमोरी उपलब्ध नहीं\n");
        return 1;
    }
    
    // इनपुट और योग साथ-साथ
    printf("%d तत्व दर्ज करें:\n", n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
        sum += arr[i];
    }
    
    printf("तत्वों का योग: %d\n", sum);
    
    // free() के बाद मेमोरी एक्सेस (प्रदर्शन के लिए)
    free(arr);
    printf("\nfree() के बाद मेमोरी सामग्री (कचरा मान):\n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);  // अपरिभाषित व्यवहार! केवल प्रदर्शन
    printf("\n");
    
    return 0;
}

आउटपुट

तत्वों की संख्या: 5
5 तत्व दर्ज करें:
23 34 12 34 56
तत्वों का योग: 159

free() के बाद मेमोरी सामग्री (कचरा मान):
12522624 0 12517712 0 56

महत्वपूर्ण चेतावनी

सुधारित संस्करण: realloc() प्रदर्शन

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = NULL;
    int capacity = 0, size = 0, val;
    
    printf "संख्याएँ दर्ज करें (0 से समाप्त):\n";
    while (scanf("%d", &val) == 1 && val != 0) {
        if (size >= capacity) {
            capacity = capacity ? capacity * 2 : 4;
            int *tmp = realloc(arr, capacity * sizeof(int));
            if (!tmp) { free(arr); return 1; }
            arr = tmp;
        }
        arr[size++] = val;
    }
    
    int sum = 0;
    for (int i = 0; i < size; i++) sum += arr[i];
    printf("कुल %d संख्याओं का योग: %d\n", size, sum);
    
    free(arr);
    return 0;
}

calloc() vs malloc()

// malloc - अनारंभिकृत
int *a = malloc(10 * sizeof(int));  // कचरा मान

// calloc - शून्य-प्रारंभिकृत
int *b = calloc(10, sizeof(int));   // सभी 0
// calloc(n, size) = malloc(n*size) + memset(0)

स्मार्ट पॉइंटर पैटर्न (C में अनुकरण)

#define AUTO_FREE __attribute__((cleanup(free_ptr)))
void free_ptr(void *p) { free(*(void**)p); }

int main() {
    AUTO_FREE int *arr = malloc(100 * sizeof(int));
    // फंक्शन अंत पर स्वतः free() कॉल होगा
}

(GCC/Clang एक्सटेंशन; C23 में मानक विशेषता संभावित)