c - मॉलोक और कॉलोक के बीच अंतर?




malloc calloc (12)

malloc (): आवंटित बाइट्स के आकार का अनुरोध किया जाता है और आवंटित स्थान के पहले बाइट को पॉइंटर देता है

कॉलोक (): किसी सरणी तत्वों के लिए स्थान आवंटित करता है, शून्य से प्रारंभ होता है और फिर स्मृति में एक सूचक देता है

करने के बीच क्या अंतर है:

ptr = (char **) malloc (MAXELEMS * sizeof(char *));

या:

ptr = (char **) calloc (MAXELEMS, sizeof(char*));

मॉलोक पर या इसके विपरीत कॉलोक का उपयोग करना एक अच्छा विचार कब है?


अंतर 1: malloc () आमतौर पर मेमोरी ब्लॉक आवंटित करता है और इसे मेमोरी सेगमेंट प्रारंभ किया जाता है। कॉलोक () मेमोरी ब्लॉक आवंटित करता है और सभी मेमोरी ब्लॉक को 0 पर प्रारंभ करता है।

अंतर 2: यदि आप malloc () वाक्यविन्यास पर विचार करते हैं, तो इसमें केवल 1 तर्क होगा। नीचे दिए गए निम्नलिखित उदाहरण पर विचार करें:

data_type ptr = (cast_type *) malloc (sizeof (data_type) * no_of_blocks);

पूर्व: यदि आप int प्रकार के लिए स्मृति के 10 ब्लॉक आवंटित करना चाहते हैं,

      int *ptr = (int *) malloc(sizeof(int) * 10 );

यदि आप कॉलोक () वाक्यविन्यास पर विचार करते हैं, तो इसमें 2 तर्क होंगे। नीचे दिए गए निम्नलिखित उदाहरण पर विचार करें:

data_type ptr = (cast_type *) कॉलोक (no_of_blocks, (sizeof (data_type)));

पूर्व: यदि आप int प्रकार के लिए स्मृति के 10 ब्लॉक आवंटित करना चाहते हैं और ज़ीरो को सभी को आरंभ करना चाहते हैं,

      int *ptr = (int *) calloc(10, (sizeof(int)));

समानता:

Malloc () और calloc () दोनों डिफ़ॉल्ट रूप से शून्य * वापस लौटाएंगे यदि वे कास्ट नहीं होते हैं।


एक अंतर अभी तक उल्लेख नहीं किया गया है: आकार सीमा

void *malloc(size_t size) केवल SIZE_MAX तक आवंटित कर सकता है।

void *calloc(size_t nmemb, size_t size); SIZE_MAX*SIZE_MAX बारे में आवंटित कर सकते हैं।

यह क्षमता अक्सर रैखिक पते के साथ कई प्लेटफार्मों में उपयोग नहीं की जाती है। ऐसे सिस्टम calloc() को nmemb * size <= SIZE_MAX साथ सीमित nmemb * size <= SIZE_MAX

disk_sector नामक 512 बाइट्स पर विचार करें और कोड कई क्षेत्रों का उपयोग करना चाहता है। यहां, कोड केवल SIZE_MAX/sizeof disk_sector सेक्टर का उपयोग कर सकता है।

size_t count = SIZE_MAX/sizeof disk_sector;
disk_sector *p = malloc(count * sizeof *p);

निम्नलिखित पर विचार करें जो एक बड़े आवंटन की अनुमति देता है।

size_t count = something_in_the_range(SIZE_MAX/sizeof disk_sector + 1, SIZE_MAX)
disk_sector *p = calloc(count, sizeof *p);

अब अगर ऐसी व्यवस्था इतनी बड़ी आवंटन की आपूर्ति कर सकती है तो एक और मामला है। आज ज्यादातर नहीं होगा। फिर भी यह कई सालों से हुआ है जब SIZE_MAX 65535 था। मूर के कानून को देखते हुए, संदेह है कि यह लगभग 2030 के साथ कुछ स्मृति मॉडल के साथ SIZE_MAX == 4294967295 और 100 SIZE_MAX == 4294967295 मेमोरी पूल के साथ होगा।


एक कम ज्ञात अंतर यह है कि लिनक्स की तरह आशावादी स्मृति आवंटन वाले ऑपरेटिंग सिस्टम में, malloc द्वारा लौटाए गए पॉइंटर को वास्तविक स्मृति द्वारा समर्थित नहीं किया जाता है जब तक कि प्रोग्राम वास्तव में इसे छूता नहीं है।

calloc वास्तव में स्मृति को स्पर्श करता है (यह उस पर शून्य लिखता है) और इस प्रकार आप सुनिश्चित होंगे कि ओएस वास्तविक रैम (या स्वैप) के साथ आवंटन का समर्थन कर रहा है। यही कारण है कि यह मॉलोक से धीमा है (न केवल इसे शून्य करना है, ओएस को अन्य प्रक्रियाओं को संभवतः स्वैप करके उपयुक्त मेमोरी एरिया भी मिलना चाहिए)

उदाहरण के लिए इस एसओ सवाल को मॉलोक के व्यवहार के बारे में और चर्चा के लिए देखें


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

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

सिंटेक्स: ptr_var=(cast_type *)calloc(no_of_blocks , size_of_each_block); यानी ptr_var=(type *)calloc(n,s);

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

सिंटेक्स: ptr_var=(cast_type *)malloc(Size_in_bytes); malloc() फ़ंक्शन एक तर्क लेता है, जो आवंटित करने के लिए बाइट्स की संख्या है, जबकि calloc() फ़ंक्शन दो तर्क लेता है, एक तत्वों की संख्या है, और दूसरा उन तत्वों के लिए आवंटित करने के लिए बाइट्स की संख्या है । इसके अलावा, calloc() आवंटित स्थान को शून्य में प्रारंभ करता है, जबकि malloc() नहीं करता है।


नाम malloc और calloc () लाइब्रेरी फ़ंक्शंस हैं जो गतिशील रूप से स्मृति आवंटित करते हैं।
इसका मतलब है कि ढेर सेगमेंट से रनटाइम (प्रोग्राम का निष्पादन) के दौरान मेमोरी आवंटित की जाती है।

प्रारंभ: malloc () दिए गए आकार (बाइट्स में) के मेमोरी ब्लॉक को आवंटित करता है और ब्लॉक की शुरुआत में पॉइंटर देता है।

>  malloc() doesn’t initialize the allocated memory. If we try to access
 the content of memory block then we’ll get garbage values. void *
> malloc( size_t size );

> calloc() allocates the memory and also initializes the allocates
 memory block to zero. If we try to access the content of these blocks
 then we’ll get 0.

> void * calloc( size_t num, size_t size );

कई तर्क: मॉलोक () के विपरीत, कॉलोक () दो तर्क लेता है: 1) आवंटित किए जाने वाले कई ब्लॉक। 2) प्रत्येक ब्लॉक का आकार।

सबसे महत्वपूर्ण :

कॉलोक पर मॉलोक का उपयोग करना बेहतर होगा, जब तक हम शून्य-प्रारंभिकरण नहीं चाहते हैं क्योंकि मॉलोक कॉलोक से तेज़ है। तो अगर हम कुछ सामान कॉपी करना चाहते हैं या ऐसा कुछ करना चाहते हैं जिसके लिए ज़ीरो के साथ ब्लॉक भरने की आवश्यकता नहीं है, तो मॉलोक बेहतर विकल्प होगा।


मॉलोक () एक एकल तर्क लेता है, जबकि कॉलोक () दो लेता है।

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


मॉलोक और कॉलोक के बीच प्रमुख अंतर हैं:

  1. मॉलोक स्मृति आवंटन के लिए खड़ा है जबकि कॉलोक संगत आवंटन के लिए खड़ा है।
  2. मॉलोक केवल एक तर्क लेता है , ब्लॉक का आकार जबकि कॉलोक दो तर्क लेता है , आवंटित किए जाने वाले ब्लॉक की संख्या और प्रत्येक ब्लॉक का आकार लेता है।

    पीआरटी = (कास्ट-टाइप *) मॉलोक (बाइट-साइज) // मॉलोक

    पीआरटी = (कास्ट-टाइप *) कॉलोक (ब्लॉक, ब्लॉक आकार का कोई नहीं); // कॉलोक

  3. मॉलोक मेमोरी प्रारंभिकता नहीं करता है और सभी पते कचरा मूल्य संग्रह करते हैं जबकि कॉलोक स्मृति प्रारंभिकता करता है और पते शून्य या शून्य मानों के लिए प्रारंभ किए जाते हैं।


calloc() शून्य-बफर शुरू करता है, जबकि malloc() स्मृति को calloc() छोड़ देता है।

संपादित करें:

स्मृति को ज़ीरोइंग करने में थोड़ा समय लग सकता है, इसलिए यदि आप प्रदर्शन एक मुद्दा है तो शायद आप malloc() का उपयोग करना चाहते हैं। यदि स्मृति प्रारंभ करना अधिक महत्वपूर्ण है, तो calloc() उपयोग करें। उदाहरण के लिए, calloc() आपको memset() को कॉल कर सकता है।


calloc आम तौर पर 0 से malloc+memset है

malloc+memset स्पष्ट रूप से उपयोग करना आम तौर पर थोड़ा बेहतर होता है, खासकर जब आप कुछ ऐसा कर रहे होते हैं:

ptr=malloc(sizeof(Item));
memset(ptr, 0, sizeof(Item));

यह बेहतर है क्योंकि sizeof(Item) संकलन समय पर संकलक को पता है और संकलक अधिकांश मामलों में इसे शून्य स्मृति के सर्वोत्तम संभव निर्देशों के साथ बदल देगा। दूसरी ओर यदि memset में calloc हो रहा है, तो आवंटन का पैरामीटर आकार calloc कोड में संकलित नहीं किया जाता है और वास्तविक memset को अक्सर बुलाया जाता है, जिसमें आम तौर पर लंबे समय तक बाइट-बाय-बाइट भरने के लिए कोड होता है, चक्र sizeof(long) भाग में स्मृति को भरने के चक्र से और आखिरकार बाइट-बाय-बाइट शेष स्थान को भरें। भले ही aligned_memset कुछ aligned_memset को कॉल करने के लिए पर्याप्त स्मार्ट है, फिर भी यह एक सामान्य लूप होगा।

एक उल्लेखनीय अपवाद तब होगा जब आप स्मृति के बहुत बड़े हिस्से (कुछ power_of_two किलोबाइट्स) के मॉलोक / कॉलोक कर रहे हों, जिसमें केस आवंटन सीधे कर्नेल से किया जा सकता है। चूंकि ओएस कर्नेल आमतौर पर सुरक्षा कारणों से दूर की जाने वाली सभी मेमोरी को शून्य कर देंगे, स्मार्ट पर्याप्त कॉलोक इसे अतिरिक्त अतिरिक्त शून्यिंग के साथ वापस कर सकता है। दोबारा - यदि आप केवल कुछ आवंटित कर रहे हैं जो आप जानते हैं तो छोटा है, तो आप मॉलोक + मेमसेट प्रदर्शन-वार के साथ बेहतर हो सकते हैं।


malloc() दिए गए आकार (बाइट्स में) के मेमोरी ब्लॉक आवंटित करता है और ब्लॉक की शुरुआत में एक सूचक देता है।

void *malloc(size_t size);

malloc() आवंटित स्मृति प्रारंभ नहीं करता है।

calloc() स्मृति को आवंटित करता है और आवंटित स्मृति को सभी बिट्स शून्य पर भी प्रारंभ करता है।

void *calloc(size_t num, size_t size);

char *ptr = (char *) malloc (n * sizeof(char));

किसी भी प्रारंभिकता के बिना स्मृति के n bytes आवंटित करता है (यानी; उन स्मृति बाइट्स में कोई कचरा मूल्य होगा)।

हालांकि, calloc() विधि malloc() करता है कि फ़ंक्शन के अलावा सभी कब्जे वाले मेमोरी बाइट्स के लिए प्रारंभिक 0 है।







calloc