C लाइब्रेरी में प्रोग्राम उदाहरण के साथ calloc() फ़ंक्शन

C में calloc क्या है?

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

मैलोक फ़ंक्शन मेमोरी स्पेस के एक ब्लॉक को आवंटित करने के लिए उपयोग किया जाता है जबकि C में calloc फ़ंक्शन का उपयोग मेमोरी स्पेस के कई ब्लॉक आवंटित करने के लिए किया जाता है। C प्रोग्रामिंग में calloc द्वारा आवंटित प्रत्येक ब्लॉक एक ही आकार का होता है।

C में calloc() का उपयोग क्यों करें?

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

calloc() के साथ डायनामिक एलोकेशन कई सामान्य स्थितियों में उपयुक्त होता है:

• संख्यात्मक सरणियाँ जो शून्य से शुरू होनी चाहिए, जैसे कि काउंटर, हिस्टोग्राम या रनिंग एक्यूमुलेटर।
• डेटा संरचनाएं जहां बचे हुए कचरा मान सूक्ष्म, कठिन-tracऔर बग।
• Bufferऐसी लंबाई जो उपयोगकर्ता द्वारा दिए गए इनपुट या प्रोग्राम चलने के दौरान पढ़ी गई फ़ाइल पर निर्भर करती है।
• ब्लॉक सीमित स्टैक के लिए बहुत बड़े हैं, क्योंकि calloc() बहुत बड़े हीप से ब्लॉक लेता है।

क्योंकि आरक्षित ब्लॉक सन्निहित है और पहले से ही शून्य है, इसलिए इसे अलग आरंभीकरण लूप के बिना तुरंत उपयोग के लिए तैयार सरणी के रूप में माना जा सकता है।

calloc() सिंटैक्स:

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

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

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

कॉलोक का उपयोग कैसे करें

सी में नीचे दिया गया 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;
    }

C उदाहरण में calloc का परिणाम:

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

calloc() और malloc() के बीच अंतर

calloc() और malloc() दोनों ही हीप पर मेमोरी आरक्षित करते हैं और दोनों ही शून्य पॉइंटर लौटाते हैं, या विफलता पर NULL लौटाते हैं, फिर भी वे तीन व्यावहारिक तरीकों से भिन्न हैं जो यह तय करते हैं कि किसका उपयोग करना है।

• आरंभीकरण: calloc() नए ब्लॉक में प्रत्येक बाइट को शून्य पर सेट करता है, जबकि malloc() सामग्री को अनआरंभिक छोड़ देता है, इसलिए malloc() ब्लॉक में प्रोग्राम द्वारा लिखे जाने तक अप्रत्याशित कचरा डेटा रहता है।
• आर्गुमेंट्स: calloc() दो आर्गुमेंट्स लेता है, तत्वों की संख्या और प्रत्येक का आकार, जिसे calloc(n, size) लिखा जाता है; malloc() एक आर्गुमेंट लेता है, बाइट्स की कुल संख्या, जिसे malloc(n * size) लिखा जाता है।
• गति: malloc() थोड़ी तेज़ है क्योंकि यह शून्य करने के चरण को छोड़ देती है, यही कारण है कि जो कोड तुरंत मेमोरी को ओवरराइट करता है वह अक्सर इसे प्राथमिकता देता है।

दोनों फ़ंक्शन stdlib.h में घोषित हैं और दोनों ही अपनी मेमोरी को free() फ़ंक्शन से मुक्त करते हैं। जब एक साफ़, शून्य-मुक्त ब्लॉक महत्वपूर्ण हो, तो calloc() का उपयोग करें, और जब तेज़ गति को प्राथमिकता दी जाए और प्रोग्राम स्वयं आरंभीकरण को संभाले, तो malloc() का उपयोग करें।

calloc() द्वारा आवंटित मेमोरी को कैसे मुक्त करें

calloc() द्वारा आरक्षित मेमोरी हीप पर रहती है और कभी भी स्वचालित रूप से मुक्त नहीं होती। जब कोई प्रोग्राम बिना मुक्त किए लगातार मेमोरी आवंटित करता रहता है, तो वह धीरे-धीरे उपलब्ध मेमोरी को पूरी तरह से समाप्त कर देता है, जिसे मेमोरी लीक कहा जाता है। free() फ़ंक्शन एक पूर्ण ब्लॉक को सिस्टम को लौटा देता है ताकि बाद में आवंटन के लिए उस स्थान का पुनः उपयोग किया जा सके।

free() फ़ंक्शन एक ही आर्गुमेंट लेता है, जो calloc() द्वारा लौटाया गया पॉइंटर होता है, और पूरे ब्लॉक को एक साथ रिलीज़ कर देता है:

int *ptr;
ptr = calloc(10, sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

calloc() मेमोरी को सुरक्षित रूप से प्रबंधित करने के लिए इन नियमों का पालन करें:

• प्रत्येक सफल calloc() के लिए free() को ठीक एक बार कॉल करें; एक ही ब्लॉक को दो बार मुक्त करने से अनिश्चित व्यवहार होता है।
• फ्री करने के बाद पॉइंटर को NULL पर सेट कर दें ताकि इसे डैंगलिंग पॉइंटर के रूप में दोबारा इस्तेमाल न किया जा सके।
• कभी भी ऐसे पॉइंटर को free() न करें जिसे calloc() ने वापस नहीं किया हो, जिसमें पॉइंटर अंकगणित द्वारा शिफ्ट किया गया पॉइंटर भी शामिल है।
• पॉइंटर के स्कोप से बाहर जाने से पहले प्रत्येक आवंटन को एक रिलीज के साथ मिलाएं।

क्योंकि calloc() और malloc() दोनों एक ही हीप से ब्लॉक लेते हैं, इसलिए दोनों फंक्शनों के लिए फ्री करने का नियम एक जैसा है: प्रत्येक सफल आवंटन के लिए एक free() फंक्शन, और उसके बाद ब्लॉक तक कोई पहुंच नहीं।ping संतुलित तरीके से मेमोरी का आवंटन और रिलीज करना C में मैन्युअल मेमोरी प्रबंधन का मूल सिद्धांत है, और यह मेमोरी लीक और पहले से वापस की जा चुकी मेमोरी के पुन: उपयोग के कारण होने वाले क्रैश दोनों को रोकता है।

अक्सर पूछे जाने वाले प्रश्न