संरचना के साथ मॉलोक का उपयोग क्यों करें?

Question

क्यों होगा मैं malloc का उपयोग जब एक ही काम के रूप में नीचे malloc के बिना किया जा सकता है ..

#include <stdio.h> 
#include <conio.h> 

struct node { 
    int data; 
    struct node *l; 
    struct node *r; 
}; 

int main(){ 
    //Case 1 
    struct node n1; 
    n1.data = 99; 
    printf("n1 data is %d\n", n1.data); 

    //Case 2 
    struct node *n2 = (struct node *) malloc (sizeof(struct node)); 
    n2 -> data = 4444; 
    printf("n2 data is:%d\n",n2 -> data); 
    free(n2); 

    return (0); 
} 

1. मैं समझता हूँ कि कैसे n1 जो स्मृति स्थान को प्रारंभ नहीं किया गया है कठिन समय चल रहा है डाटा स्टोर करने में सक्षम है (99)।
2. जब मामले का उपयोग करने के 2.
   

Answer 1

क्यों होगा .. मैं malloc का उपयोग जब एक ही काम गन्ना नीचे के रूप में malloc बिना द्वारा किया जा

आप malloc का उपयोग , ढेर पर स्मृति आवंटित करने के लिए, और मॉलोक के बिना, आप ढेर स्मृति में संरचना रख रहे हैं।

मैं समझता हूँ कि कैसे n1 जो स्मृति स्थान पर आरंभ नहीं किया है कठिन समय चल रहा है डेटा (99) स्टोर करने के लिए सक्षम है।

प्रारंभ या नहीं, जब आप डेटा n1.data = 99; निर्दिष्ट करते हैं, तो यह संग्रहीत होता है।

2) जब मामला 1 और जब उपयोग करने के लिए मामला 2

केस 1 उपयोग करने के लिए प्रयोग किया जाता है, जब आप जानते हैं कि आप एक सीमित दायरे के भीतर संरचना वस्तु का उपयोग किया जाएगा, और नहीं होगा अपने दायरे से परे, संरचना डेटा के संदर्भ बना रहे हैं।

केस 2 का उपयोग तब किया जाता है जब आप कई स्थानों पर अपनी संरचना का उपयोग करेंगे, और आप मैन्युअल रूप से इसके लिए मेमोरी प्रबंधित करने के इच्छुक हैं (और ध्यान से!)। इस विधि का लाभ यह है कि, आप प्रोग्राम स्कोप के कुछ हिस्सों में संरचना बनाते हैं और प्रारंभ करते हैं, और आप एक पॉइंटर बनाते हैं और पॉइंटर पास करते हैं, क्योंकि 4 बाइट पॉइंटर पास करने से संरचना को पार करने से कहीं अधिक कुशल होता है।

Answer 2

पहले मामले में मामला 1 और जब उपयोग करने के लिए, स्मृति ढेर पर आवंटित किया जाता है। जब चर n1 गुंजाइश से बाहर हो जाता है, तो स्मृति जारी की जाती है।

दूसरे मामले में, ढेर पर स्मृति आवंटित की जाती है। आपको स्मृति संसाधनों को स्पष्ट रूप से रिलीज़ करना होगा (जैसा कि आप free के साथ कर रहे हैं)।

नियम-का-अंगूठे यह हो सकता है कि आप सीमित आकार के स्थानीय, अस्थायी डेटा संरचनाओं के लिए स्टैक-आवंटित स्मृति का उपयोग करें (ढेर कंप्यूटर की स्मृति का केवल एक हिस्सा है, प्रति प्लेटफॉर्म अलग है)। उन डेटा संरचनाओं के ढेर का उपयोग करें जिन्हें आप जारी रखना चाहते हैं या बड़े हैं।

stack and heap के लिए गुगलिंग आपको और अधिक जानकारी देगा।

Answer 3

int main() { 
    struct node n1; 
    n1.data = 99 

ढेर पर इस भंडार अंतरिक्ष (main के फ्रेम में) एक struct node के आकार के बराबर है। इसे स्थानीय के रूप में जाना जाता है, और यह केवल main के संदर्भ में मौजूद है।

struct node *n2 = (struct node *) malloc (sizeof(struct node)); 

यह ढेर पर आवंटन है। यह स्मृति मौजूद है चाहे आप किस फ़ंक्शन संदर्भ में हों। इसे आमतौर पर "गतिशील आवंटन" कहा जाता है।

ये node संरचना linked list के लिए आधार हैं, जो इच्छाओं पर नोड्स को जोड़ा, हटाया जा सकता है, फिर से आदेश दिया जा सकता है आदि।

यह भी देखें:

• What and where are the stack and heap?

Answer 4

आम तौर पर आप केवल मॉलोक का उपयोग करते हैं, यदि आप स्मृति के आकार को नहीं जानते हैं तो आपको एप्लिकेशन चलाने से पहले आवश्यकता होगी।

आपका कोड सही है, लेकिन आप गतिशील रूप से स्मृति आवंटित नहीं कर सकते हैं। क्या होगा यदि आप node.date में एक मापा मान सहेजना चाहते हैं और आप नहीं जानते हैं, तो आप कितने उपाय कैप्चर करेंगे? फिर आपको अपने द्वारा उठाए गए प्रत्येक उपाय पर कुछ नई याददाश्त करना होगा।

यदि आप रन-टाइम (सीधे कोड में) से पहले सभी नोड्स को परिभाषित करते हैं, तो आप पहले परिभाषित किए गए अधिक उपायों को सहेज नहीं सकते हैं।

सी में लिंक्ड सूचियों के लिए खोजें और आपको कुछ अच्छे उदाहरण मिलेंगे।

Answer 5

आपका डेटा प्रकार पेड़ में नोड की तरह दिखता है। दो प्राथमिक कारण पेड़ नोड आवंटन के लिए malloc उपयोग करने के लिए

1. नोड्स के मनमाना संख्या आवंटित करने के लिए किया जाएगा। आम तौर पर पेड़ नोड्स की संख्या रन-टाइम मान होगी। इस कारण से, ऐसे नोड्स के लिए स्थानीय चर की उचित संख्या घोषित करना असंभव है क्योंकि संकलन समय पर सभी स्थानीय चर घोषित किए जाने चाहिए। इस बीच, malloc जितनी बार चाहें उतनी बार रन-टाइम में बुलाया जा सकता है, जितना आपको आवश्यक नोड ऑब्जेक्ट आवंटित करता है।

2. यह सुनिश्चित करने के लिए कि स्थानीय ऑब्जेक्ट का जीवनकाल समाप्त होने पर नोड स्वचालित रूप से नष्ट नहीं होता है (यानी ब्लॉक के अंत में)। malloc द्वारा आवंटित ऑब्जेक्ट्स हमेशा, यानी जब तक आप उन्हें free पर कॉल करके स्पष्ट रूप से नष्ट नहीं करते हैं। ऐसी वस्तु ब्लॉक सीमाओं और कार्य सीमाओं से आगे बढ़ जाएगी। स्थानीय वस्तुओं के साथ ऐसा कुछ भी संभव नहीं है, क्योंकि स्थानीय वस्तुओं को अपने ब्लॉक के अंत में स्वचालित रूप से नष्ट कर दिया जाता है।

आपका कोड नमूना गतिशील आवंटन के किसी भी लाभ पर निर्भर नहीं है, क्योंकि यह वास्तव में एक असली पेड़ बनाते हैं। यह सिर्फ एकल नोड के रूप में घोषित किया गया। लेकिन यदि आप नोड्स के रन-टाइम नंबर के साथ एक पूर्ण पेड़ बनाने का प्रयास करते हैं, तो आपको तुरंत पता चलेगा कि नोड्स को स्थानीय वस्तुओं के रूप में घोषित करना असंभव है। आपको malloc का उपयोग करके अपने नोड्स को असामान्य रूप से आवंटित करना होगा।

आपका "कैसे n1 जो स्मृति स्थान में प्रारंभ नहीं किया गया है डेटा संग्रह करने में सक्षम है" प्रश्न कुछ भ्रम के कारण होना चाहिए। struct node n1; एक ऑब्जेक्ट परिभाषा है, जिसका अर्थ है कि यह n1 के लिए स्मृति स्थान असाइन करता है। यह ऑब्जेक्ट परिभाषा का बिल्कुल सही उद्देश्य है।