C ++ को C ++ में बदलना: मेमोरी को मैन्युअल रूप से प्रबंधित करना

इस लेख में मैं यह दिखाना चाहता हूं कि आप C # में मैन्युअल मेमोरी मैनेजमेंट कैसे कर सकते हैं और फिर इसके साथ एक साधारण यूनिडायरेक्शनल सूची बना सकते हैं।

बीज के लिए, आइए थोड़ा आगे चलें और दिखाएं कि आखिरकार, इस तरह की सूची का एक उदाहरण कैसे बनाया जाएगा:

new CustomLinkedList< double , ListBasedAllocator<CustomLinkedListNode< double , int >>, int >()

तुरंत सहमत हूं कि हम असुरक्षित संदर्भ का उपयोग नहीं करेंगे। यह पोर्टेबिलिटी को कम करता है और दावा की गई सूची को विकसित करते समय आपको मिलने वाली सभी खुशी को खत्म कर देता है।

खुद के संकेत

सौभाग्य से (!), .NET पॉइंटर्स का समर्थन नहीं करता है क्योंकि C ++ उनका समर्थन करता है। प्रबंधित कोड विकसित करते समय यह सब उपलब्ध है

• संदर्भ प्रकार के उदाहरण। इन सभी को ढेर पर संग्रहीत किया जाता है और कचरा कलेक्टर द्वारा परोसा जाता है। जैसा कि हम अपने स्मृति प्रबंधन को लिखते हैं, आप तुरंत उनके बारे में भूल सकते हैं।
• मूल्य प्रकार के बॉक्सिंग उदाहरण। सिद्धांत रूप में, वे संदर्भ प्रकारों के उदाहरणों से बहुत कम हैं और समान कारणों से हमारे लिए उपयुक्त नहीं हैं।
• प्रबंधित पॉइंटर्स। वे ढेर और ढेर दोनों को इंगित कर सकते हैं। जहां तक ​​मुझे पता है, वे केवल स्थानीय चर में संग्रहीत किए जा सकते हैं और / या कॉल किए जाने पर अन्य कार्यों में पारित हो सकते हैं। इसलिए, वे हमारे अनुकूल नहीं होंगे।

हम इस समस्या को आसानी से हल करेंगे: हम इसे इस स्तर पर हल नहीं करेंगे, लेकिन इसे बेहतर समय तक स्थगित कर देंगे। इस बीच, हम हर जगह टाइप पॉइंटर के एक पैरामीटर का उपयोग करने के लिए सहमत हैं।

कंटेनरों में निहित संरचनाओं का संशोधन

इस लेख में, मैं निश्चित आकार के डेटा संरचनाओं के लिए आवंटनकर्ताओं पर विचार करूंगा। हम इस तरह के आवंटनकर्ता के इंटरफेस का वर्णन करते हैं:

1. /// <सारांश>
2. /// एक निश्चित प्रकार की वस्तुओं के आवंटन के लिए सामान्यीकृत इंटरफ़ेस।
3. /// </ सारांश>
4. /// <typeparam name = "T"> ऑब्जेक्ट्स का प्रकार जो कि एलोकेटर </ typeparam> के साथ काम करता है
5. /// <typeparam name = "TPointer"> मेमोरी को एक्सेस करने के लिए उपयोग किए जाने वाले पॉइंटर का प्रकार </ typeparam>
6. सार्वजनिक इंटरफ़ेस ICustomTypeAllocator <T, TPointer>
7. {
8. /// <सारांश>
9. /// एक ऑब्जेक्ट के लिए एक मेमोरी क्षेत्र का चयन करता है और इस क्षेत्र के लिए एक पॉइंटर लौटाता है
10. /// </ सारांश>
11. TPointer आवंटित ();
12. /// <सारांश>
13. /// सूचक में मेमोरी मेमोरी।
14. /// यदि checkErrors ध्वज सेट किया गया है, तो यदि संभव हो तो आवंटन चेक करता है
15. /// कि यह पॉइंटर वास्तव में पहले से आवंटित मेमोरी ब्लॉक की ओर इशारा करता है,
16. /// और, अगर यह नहीं है, तो एक अपवाद फेंकता है।
17. /// </ सारांश>
18. /// <param name = "पॉइंटर"> इंगित किए जाने वाले मेमोरी क्षेत्र को इंगित करें </ param>
19. /// <param name = "checkErrors"> </ param>
20. शून्य मुक्त (TPointer सूचक, बूल जाँचक = गलत );
21. /// <सारांश>
22. /// एड्रेस पॉइंटर पर ऑब्जेक्ट को एक्सेस करने की अनुमति देता है।
23. /// </ सारांश>
24. /// <परम नाम = "सूचक"> उस स्मृति क्षेत्र का पता जिसमें वस्तु स्थित है। </ param>
25. टी इस [TPointer सूचक] { मिलता है ; सेट ; }
27. /// <सारांश>
28. /// ऐसा पॉइंटर लौटाता है जो हमेशा अमान्य होता है
29. /// </ सारांश>
30. TPointer InvalidPointer { मिलता है ; }
31. /// <सारांश>
32. /// जाँच करता है कि निर्दिष्ट पॉइंटर मान्य है या नहीं।
33. /// </ सारांश>
34. /// <param name = "पॉइंटर"> चेक करने के लिए पॉइंटर </ param>
35. बूल IsPointerValid (TPointer सूचक);
36. }

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

जब हम इस इंटरफ़ेस (या शायद पहले) का उपयोग करने का प्रयास करते हैं, तो हम निम्नलिखित समस्या पर आएंगे:

var pointer = allocator.Allocate();
allocator[pointer].Value = 0;

यदि हमने टाइप-टी को टी (जैसे, यह हमारा प्राथमिक लक्ष्य है) के रूप में निर्दिष्ट किया है, तो निर्दिष्ट कोड संकलित नहीं होगा। कारण सरल है: आवंटनकर्ता [सूचक] ऑपरेशन का परिणाम निर्दिष्ट पते पर निहित संरचना की एक प्रति होगी, न कि संरचना ही। मैं समस्या से दो तरीके जानता हूं:

1. एक अस्थायी चर के लिए आबंटक [सूचक] के परिणाम को सहेजें, संरचना पर आवश्यक संचालन करें और इसे वापस लिखें।
2. आवंटन इंटरफ़ेस में एक फ़ंक्शन जोड़ें जो निर्दिष्ट पते पर एक निर्दिष्ट तरीके से मूल्य को संशोधित करेगा।

दूसरे रास्ते से चलते हैं। ऐसा करने के लिए, एक प्रतिनिधि प्रकार घोषित करें जो संदर्भ द्वारा एक पैरामीटर लेता है और शून्य देता है: public delegate void Modifier<T>( ref T value ); और हमारे इंटरफ़ेस में एक संशोधक फ़ंक्शन जोड़ें:

1. /// <सारांश>
2. /// दिए गए पॉइंटर पते पर ऑब्जेक्ट को संशोधक फ़ंक्शन को कॉल करके संशोधित करता है
3. /// </ सारांश>
4. /// <परम नाम = "सूचक"> एक परस्पर वस्तु को इंगित करता है </ param>
5. /// <param name = "modifier"> फ़ंक्शन जो किसी ऑब्जेक्ट के मान को बदल देगा </ param>
6. शून्य सेट (TPointer सूचक, संशोधक <T> संशोधक);

डिफ़ॉल्ट रूप से, हमारे पास पॉइंटर्स स्टोर करने के लिए कहीं नहीं है

मैं मुक्त नोड्स की सूची के आधार पर आवंटनकर्ता के कार्यान्वयन पर विचार करूंगा। C ++ के साथ, सब कुछ सरल है: उपयोगकर्ता द्वारा प्रबंधित की जाने वाली मेमोरी में उपयोगकर्ता किस प्रकार संग्रहीत करना चाहता है, इससे कोई फर्क नहीं पड़ता, हम उपयोगकर्ता संरचना के संघ के रूप में तत्व का प्रतिनिधित्व कर सकते हैं और संरचना में ठीक एक तत्व है - सूची में अगले मुक्त तत्व के लिए एक सूचक। असुरक्षित संदर्भ के बाहर .NET जुड़ने का समर्थन नहीं करता है। इसलिए, यह आवश्यक है कि हमारे आवंटनकर्ता का उपयोगकर्ता हमें स्पष्ट रूप से पॉइंटर स्टोर करने की जगह प्रदान करे। ऐसा करने के लिए, हम पॉइंटर नोड {के एकमात्र सदस्य के साथ ILinkedListNode इंटरफ़ेस की घोषणा करेंगे; सेट; }, और हमें आवश्यकता है कि एलिमिनेटर काम करने वाले तत्व का प्रकार इस इंटरफ़ेस से विरासत में मिला है।

public class ListBasedAllocator<T>: ICustomTypeAllocator<T, int > where T: ILinkedListNode< int >

आवंटन और सूची कार्यान्वयन

मेरा मानना ​​है कि प्रत्येक स्वाभिमानी प्रोग्रामर को मुफ्त नोड्स की सूची और इसके अलावा, एक यूनिडायरेक्शनल सूची को लागू करने में सक्षम होना चाहिए। यह सब वर्णित है, उदाहरण के लिए, कॉर्मेन की पुस्तक में।
पूर्ण कार्यान्वयन के लिए स्रोत कोड (C # में) और परीक्षण मामला (F # में) डाउनलोड या यहाँ देखा जा सकता है ।

निष्कर्ष में

संभवत:, सूची को लागू करने के लिए कोड की मात्रा और इसे एफ # में फिर से लिखकर टाइप इंट्रेंस के कारण कम किया जा सकता है।

आपको अभी तक उत्पादन में इस तरह के जादू का उपयोग नहीं करना चाहिए। :)

पुनश्च यह अभी भी होगा!