यूनिक्स फोर्क के बाद गतिशील रूप से आवंटित स्मृति के लिए पॉइंटर्स के साथ क्या होता है?

Question

कोई व्यक्ति कृपया स्पष्ट करें कि एक कांटा() के बाद पॉइंटर्स के साथ क्या होता है।

जैसा कि मैं इसे समझता हूं, स्टैक या स्थिर आवंटित पर कुछ भी पॉइंटर्स स्टैक/डेटा सेगमेंट रजिस्टरों के सापेक्ष हैं, इसलिए उन्हें एक कांटा के दौरान बिल्कुल कॉपी करना ठीक है।

हालांकि, अगर मैं malloc() को फोर्किंग से पहले कुछ करता हूं तो क्या होता है?

void* p = malloc(64); 
// put something in *p; 
fork(); 

// what happens to p and the memory i allocated here? 

संभावनाओं मैं सोच रहा हूँ: उदाहरण के लिए

1. * p ढेर के किसी अन्य भाग में कॉपी किया है, पी नई-नई कॉपी स्थान प्रतिबिंबित करने के लिए अद्यतन किया जाता है।

2. पी अभी भी मूल को इंगित करता है। अगर कोई बच्चा मुफ्त चलाता है (पी); माता-पिता इसे एक्सेस करने में असमर्थ हो सकते हैं।

3. पी अभी भी मूल डेटा को इंगित करता है, लेकिन बाल प्रक्रिया में स्मृति को एक्सेस/प्रबंधित करने का अधिकार नहीं है।

इनमें से कौन सा, यदि कोई है, तो सही है?

Answer 1

जब forking, बच्चे प्रक्रिया एक प्रति अपने पेरेंट की हो जाता है। इसमें किसी भी गतिशील आवंटित स्मृति शामिल है। तो स्मृति की प्रतिलिपि बनाई जाएगी। सूचक पता वही रहेगा (प्रतिलिपि डेटा नहीं बदलती है, याद है?), जिसे virtual addressing द्वारा हासिल किया जाता है। माता-पिता और बाल प्रक्रियाओं में free पर कॉल करना न भूलें।

Answer 2

मूल्य भी कॉपी किया गया है, फोर्क प्रतियां कोड, ग्लोबल्स, ढेर और ढेर के रूप में।

स्रोत: http://web.eecs.utk.edu/~huangj/cs360/360/notes/Fork/lecture.html

Answer 3

Malloced स्मृति ढेर, जो स्मृति पृष्ठों का एक सेट के लिए सिर्फ एक फैंसी शब्द है से आता है। चूंकि fork() पाठ्यपुस्तकों में दिए गए किसी भी फैंसी नामकरण के बावजूद सभी प्रक्रियाओं के स्मृति पृष्ठों की प्रतिलिपि बनाते हैं, तो फोर्क() द्वारा लौटाए गए पॉइंटर्स बच्चे में ठीक काम करते हैं :-)