C में malloc(), calloc() फ़ंक्शन का उपयोग करके गतिशील मेमोरी आवंटन

इससे पहले कि आप C डायनेमिक मेमोरी आवंटन सीखें, आइए समझते हैं:

सी में मेमोरी प्रबंधन कैसे काम करता है?

जब आप किसी मूल डेटा प्रकार का उपयोग करके एक चर घोषित करते हैं, तो सी कंपाइलर स्वचालित रूप से मेमोरी के एक पूल में चर के लिए मेमोरी स्थान आवंटित करता है जिसे मेमोरी प्रकार कहा जाता है। धुआँरा.

उदाहरण के लिए, एक फ़्लोट वैरिएबल को घोषित करते समय आम तौर पर 4 बाइट्स (प्लेटफ़ॉर्म के अनुसार) लगते हैं। हम इस जानकारी को सत्यापित करने के लिए इसका उपयोग कर सकते हैं इस आकार का ऑपरेटर जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है

#include <stdio.h>
int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

उत्पादन हो जाएगा:

 The size of float is 4 bytes

इसके अलावा, निर्दिष्ट आकार वाली एक सरणी को मेमोरी के सन्निहित ब्लॉकों में आवंटित किया जाता है, प्रत्येक ब्लॉक में एक तत्व का आकार होता है:

#include <stdio.h>
int main() { float arr[10];
printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;}

परिणाम है:

 The size of the float array with 10 element is 40

जैसा कि अब तक सीखा गया है, जब कोई बुनियादी डेटा प्रकार या सरणी घोषित की जाती है, तो मेमोरी स्वचालित रूप से प्रबंधित होती है। हालाँकि, C में मेमोरी आवंटित करने की एक प्रक्रिया है जो आपको एक प्रोग्राम को लागू करने की अनुमति देगी जिसमें सरणी का आकार तब तक अनिश्चित रहता है जब तक आप अपना प्रोग्राम नहीं चलाते (रनटाइम)। इस प्रक्रिया को "गतिशील स्मृति आवंटन".

अब आप बिना किसी समस्या के रनटाइम पर गतिशील रूप से तत्वों की एक सरणी बना और नष्ट कर सकते हैं। संक्षेप में, स्वचालित मेमोरी प्रबंधन स्टैक का उपयोग करता है, और सी डायनेमिक मेमोरी आवंटन हीप का उपयोग करता है।

लाइब्रेरी में डायनामिक मेमोरी प्रबंधन के लिए जिम्मेदार फ़ंक्शन हैं।

समारोह	उद्देश्य
malloc ()	अनुरोधित आकार की मेमोरी आवंटित करता है और पहले बाइट का पॉइंटर लौटाता है आवंटित स्थान.
कॉलोक ()	किसी सारणी के तत्वों के लिए स्थान आवंटित करता है। तत्वों को शून्य पर आरंभ करता है और मेमोरी में एक पॉइंटर लौटाता है।
रीयलोक ()	इसका उपयोग पहले से आबंटित मेमोरी स्थान के आकार को संशोधित करने के लिए किया जाता है।
मुक्त()	पहले से आवंटित मेमोरी स्थान को मुक्त या रिक्त करता है।

आइये उपरोक्त कार्यों और उनके अनुप्रयोग पर चर्चा करें

malloc() फ़ंक्शन का सिंटैक्स:

ptr = (cast_type *) malloc (byte_size);

यहाँ,

• ptr cast_type का सूचक है.
• C malloc() फ़ंक्शन byte_size की आवंटित मेमोरी के लिए एक पॉइंटर लौटाता है।

malloc() का उदाहरण:

Example: ptr = (int *) malloc (50)

जब यह कथन सफलतापूर्वक निष्पादित होता है, तो 50 बाइट्स का मेमोरी स्पेस आरक्षित हो जाता है। आरक्षित स्थान के पहले बाइट का पता int प्रकार के पॉइंटर ptr को असाइन किया जाता है।

एक अन्य उदाहरण पर विचार करें:

#include <stdlib.h>
int main(){
int *ptr;
ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */
    if (ptr != NULL) {
      *(ptr + 5) = 480; /* assign 480 to sixth integer */
      printf("Value of the 6th integer is %d",*(ptr + 5));
    }
}

आउटपुट:

Value of the 6th integer is 480

1. सूचना है कि आकार(*ptr) के स्थान पर प्रयोग किया गया आकार(int) बाद में जब *ptr घोषणा को किसी भिन्न डेटा प्रकार में टाइपकास्ट किया जाता है तो कोड को अधिक मजबूत बनाने के लिए।
2. यदि मेमोरी पर्याप्त नहीं है तो आवंटन विफल हो सकता है। इस मामले में, यह एक NULL पॉइंटर लौटाता है। इसलिए, आपको NULL पॉइंटर की जांच करने के लिए कोड शामिल करना चाहिए।
3. ध्यान रखें कि आवंटित मेमोरी सन्निहित है और इसे एक सरणी के रूप में माना जा सकता है। हम कोष्ठक [ ] का उपयोग करने के बजाय सरणी तत्वों तक पहुँचने के लिए पॉइंटर अंकगणित का उपयोग कर सकते हैं। हम सरणी तत्वों को संदर्भित करने के लिए + का उपयोग करने की सलाह देते हैं क्योंकि वृद्धि ++ या += का उपयोग करने से सरणी द्वारा संग्रहीत पता बदल जाता है। सूचक.

Malloc() फ़ंक्शन का उपयोग कैरेक्टर डेटा प्रकार के साथ-साथ संरचनाओं जैसे जटिल डेटा प्रकारों के साथ भी किया जा सकता है।

उदाहरण के लिए:

#include <stdio.h>
int main() {
int* ptr = malloc(10 * sizeof(*ptr));
if (ptr != NULL){
  *(ptr + 2) = 50;
  printf("Value of the 2nd integer is %d",*(ptr + 2));
}
free(ptr);
}

आउटपुट:

 Value of the 2nd integer is 50

calloc() फ़ंक्शन का सिंटैक्स:

ptr = (cast_type *) calloc (n, size);

• उपरोक्त कथन का उपयोग समान आकार के n मेमोरी ब्लॉक आवंटित करने के लिए किया जाता है।
• मेमोरी स्पेस आवंटित होने के बाद, सभी बाइट्स को शून्य पर आरंभीकृत कर दिया जाता है।
• वह पॉइंटर जो वर्तमान में आवंटित मेमोरी स्थान के प्रथम बाइट पर है, लौटा दिया जाता है।

जब भी मेमोरी स्थान आबंटन में कोई त्रुटि होती है, जैसे मेमोरी की कमी, तो एक शून्य सूचक लौटा दिया जाता है।

calloc() का उदाहरण:

नीचे दिया गया प्रोग्राम एक अंकगणितीय अनुक्रम का योगफल गणना करता है।

#include <stdio.h>
    int main() {
        int i, * ptr, sum = 0;
        ptr = calloc(10, sizeof(int));
        if (ptr == NULL) {
            printf("Error! memory not allocated.");
            exit(0);
        }
        printf("Building and calculating the sequence sum of the first 10 terms \ n ");
        for (i = 0; i < 10; ++i) { * (ptr + i) = i;
            sum += * (ptr + i);
        }
        printf("Sum = %d", sum);
        free(ptr);
        return 0;
    }

रिजल्ट:

Building and calculating the sequence sum of the first 10 terms
Sum = 45

calloc() बनाम malloc(): मुख्य अंतर

इनके बीच मुख्य अंतर निम्नलिखित है malloc() बनाम calloc() सी में:

calloc() फ़ंक्शन आम तौर पर malloc() फ़ंक्शन की तुलना में अधिक उपयुक्त और कुशल होता है। जबकि दोनों फ़ंक्शन का उपयोग मेमोरी स्पेस आवंटित करने के लिए किया जाता है, calloc() एक ही समय में कई ब्लॉक आवंटित कर सकता है। आपको हर बार मेमोरी ब्लॉक के लिए अनुरोध करने की आवश्यकता नहीं है। calloc() फ़ंक्शन का उपयोग जटिल डेटा संरचनाओं में किया जाता है जिसके लिए बड़ी मेमोरी स्पेस की आवश्यकता होती है।

सी में calloc() द्वारा आवंटित मेमोरी ब्लॉक को हमेशा शून्य पर आरंभीकृत किया जाता है, जबकि सी में फंक्शन malloc() में, इसमें हमेशा एक कचरा मान होता है।

realloc() फ़ंक्शन का सिंटैक्स:

ptr = realloc (ptr,newsize);

उपरोक्त कथन newsize चर में निर्दिष्ट आकार के साथ एक नया मेमोरी स्पेस आवंटित करता है। फ़ंक्शन निष्पादित करने के बाद, पॉइंटर मेमोरी ब्लॉक के पहले बाइट पर वापस आ जाएगा। नया आकार पिछली मेमोरी से बड़ा या छोटा हो सकता है। हम यह सुनिश्चित नहीं कर सकते कि नया आवंटित ब्लॉक पिछले मेमोरी ब्लॉक के समान स्थान पर इंगित करेगा या नहीं। यह फ़ंक्शन नए क्षेत्र में पिछले सभी डेटा की प्रतिलिपि बनाएगा। यह सुनिश्चित करता है कि डेटा सुरक्षित रहेगा।

realloc() का उदाहरण:

#include <stdio.h>
int main () {
   char *ptr;
   ptr = (char *) malloc(10);
   strcpy(ptr, "Programming");
   printf(" %s,  Address = %u\n", ptr, ptr);

   ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size
   strcat(ptr, " In 'C'");
   printf(" %s,  Address = %u\n", ptr, ptr);
   free(ptr);
   return 0;
}

जब भी C में realloc() के परिणामस्वरूप कोई ऑपरेशन असफल होता है, तो यह शून्य पॉइंटर लौटाता है, और पिछला डेटा भी मुक्त हो जाता है।

#include <stdio.h>
    int main() {
        int * arr_dynamic = NULL;
        int elements = 2, i;
        arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks
        for (i = 0; i < elements; i++) arr_dynamic[i] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        elements = 4;
        arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elements
        printf("After realloc\n");
        for (i = 2; i < elements; i++) arr_dynamic[i] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        free(arr_dynamic);
    }

स्क्रीन पर सी डायनेमिक ऐरे प्रोग्राम का परिणाम:

 
arr_dynamic[0]=0
arr_dynamic[1]=1
After realloc
arr_dynamic[0]=0
arr_dynamic[1]=1
arr_dynamic[2]=2
arr_dynamic[3]=3

सारांश

• हम हीप में आवश्यकतानुसार मेमोरी ब्लॉक बनाकर मेमोरी को गतिशील रूप से प्रबंधित कर सकते हैं
• सी डायनेमिक मेमोरी एलोकेशन में, मेमोरी को रन टाइम पर आवंटित किया जाता है।
• गतिशील मेमोरी आवंटन स्ट्रिंग्स और एरे में हेरफेर करने की अनुमति देता है जिनका आकार लचीला होता है और आपके प्रोग्राम में कभी भी बदला जा सकता है।
• इसकी आवश्यकता तब होती है जब आपको पता नहीं होता कि कोई विशेष संरचना कितनी मेमोरी घेरेगी।
• C में Malloc() एक गतिशील मेमोरी आवंटन फ़ंक्शन है जो मेमोरी आवंटन के लिए खड़ा है जो विशिष्ट आकार के साथ मेमोरी के ब्लॉक को कचरा मान से आरंभ करता है
• C में Calloc() एक निरंतर मेमोरी आवंटन फ़ंक्शन है जो 0 से आरंभ करके एक समय में कई मेमोरी ब्लॉक आवंटित करता है
• सी में Realloc() का उपयोग निर्दिष्ट आकार के अनुसार मेमोरी को पुनः आवंटित करने के लिए किया जाता है।
• Free() फ़ंक्शन का उपयोग गतिशील रूप से आवंटित मेमोरी को साफ़ करने के लिए किया जाता है।