ऑपरेंड सरणी के आकार को [] "पता" कैसे हटाता है?

Question

Foo* set = new Foo[100]; 
// ... 
delete [] set; 

आप सरणी की सीमाओं को delete[] पर पास नहीं करते हैं। लेकिन वह जानकारी कहाँ संग्रहित है? क्या यह मानकीकृत है?

Answer 1

जब आप ढेर पर स्मृति आवंटित करते हैं, तो आपका आवंटक ट्रैक करेगा कि आपने कितनी मेमोरी आवंटित की है। यह आमतौर पर आपके द्वारा आवंटित स्मृति से पहले "हेड" सेगमेंट में संग्रहीत होता है। इस तरह जब स्मृति को मुक्त करने का समय होता है, तो डी-आवंटक जानता है कि कितनी मेमोरी मुक्त है।

Answer 2

यह कुछ ऐसा नहीं है जो कल्पना में है - यह कार्यान्वयन निर्भर है।

Answer 3

क्योंकि 'हटाया' सरणी को 'नए' ऑपरेटर के एक ही उपयोग के साथ बनाया जाना चाहिए था। 'नए' ऑपरेशन ने उस जानकारी को ढेर पर रखा होगा। अन्यथा, नए पता के अतिरिक्त उपयोग कैसे करेंगे जहां ढेर समाप्त होता है?

Answer 4

यह मानकीकृत नहीं है। माइक्रोसॉफ्ट के रनटाइम में नया ऑपरेटर malloc() का उपयोग करता है और डिलीट ऑपरेटर मुफ्त() का उपयोग करता है। इसलिए, इस सेटिंग में आपका प्रश्न निम्न के बराबर है: मुक्त() ब्लॉक के आकार को कैसे जानता है?

दृश्यों के पीछे कुछ बहीखाता चल रही है, यानी सी रनटाइम में।

Answer 5

जानकारी मानकीकृत नहीं है। हालांकि इस जानकारी पर मैंने जिन प्लेटफॉर्म पर काम किया है, उनमें पहले तत्व से पहले स्मृति में संग्रहीत किया गया है। इसलिए आप सैद्धांतिक रूप से इसका उपयोग कर सकते हैं और इसका निरीक्षण कर सकते हैं, हालांकि यह इसके लायक नहीं है।

यही कारण है कि जब आप हटाए गए सरणी संस्करण को जानते हैं कि (और कहां) इसे सही मात्रा में स्मृति मुक्त करने की आवश्यकता है - और कहें तो कॉल को हटाएं [] वस्तुओं के लिए विनाशकों की उचित संख्या।

Answer 6

यह संकलक विशिष्ट होने के लिए सी ++ मानक में परिभाषित किया गया है। जिसका मतलब कंपाइलर जादू है। यह कम से कम एक प्रमुख मंच पर गैर-तुच्छ संरेखण प्रतिबंधों के साथ तोड़ सकता है।

आप एहसास है कि delete[] केवल new[] द्वारा दिया संकेत दिए गए, जो एक ही सूचक के रूप में operator new[] द्वारा वापस नहीं हो सकता है के लिए परिभाषित किया गया है के द्वारा ही संभव कार्यान्वयन के बारे में सोच सकते हैं। जंगली में एक कार्यान्वयन operator new[] द्वारा लौटाए गए पहले int में सरणी गणना को संग्रहीत करना है, और new[] उस पर एक पॉइंटर ऑफ़सेट लौटाता है। (यही कारण है कि गैर-तुच्छ संरेखण new[] तोड़ सकते हैं।)

ध्यान रखें कि operator new[]/operator delete[]! = new[]/delete[]।

प्लस, यह ऑर्थोगोनल है कि सी malloc द्वारा आवंटित स्मृति के आकार को कैसे जानता है।

Answer 7

मूल रूप से के रूप में स्मृति में अपनी व्यवस्था की:

[जानकारी] [मेम के लिए कहा के लिए ...]

कहाँ जानकारी अपने संकलक द्वारा इस्तेमाल किया आवंटित स्मृति की मात्रा है, और क्या स्टोर करने के लिए संरचना है नहीं।

यह कार्यान्वयन हालांकि निर्भर है।

Answer 8

कंपाइलर्स के दृष्टिकोण में से एक को थोड़ा और स्मृति आवंटित करना और एक प्रमुख तत्व में तत्वों की गिनती को स्टोर करना है।

उदाहरण यह कैसे किया जा सकता है:

यहाँ

int* i = new int[4]; 

संकलक sizeof(int)*5 बाइट्स आवंटित करेगा।

int *temp = malloc(sizeof(int)*5) 

स्टोर करेगा "4" पहले sizeof(int) बाइट्स

*temp = 4; 

में और 4 तत्वों की एक सरणी के लिए i

i = temp + 1; 

तो i होगा अंक निर्धारित करते हैं, नहीं 5.

और हटाने

delete[] i; 

निम्नलिखित तरीके से कार्रवाई की जाएगी:

int *temp = i - 1; 
int numbers_of_element = *temp; // = 4 
... call destructor for numbers_of_element elements 
... that are stored in temp + 1, temp + 2, ... temp + 4 if needed 
free (temp) 

Answer 9

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

सबसे पहले, जबकि कुछ स्तर पर आपके सिस्टम को यह पता होना चाहिए कि स्मृति ब्लॉक को कैसे मुक्त किया जाए, अंतर्निहित मॉलोक/फ्री (जो नया/हटाएं/नया []/हटाएं [] आम तौर पर कॉल करें) हमेशा याद न करें वास्तव में आप कितनी मेमोरी मांगते हैं, यह गोलाकार हो सकता है (उदाहरण के लिए, एक बार जब आप 4K से ऊपर हो जाते हैं तो इसे अक्सर अगले 4 के आकार के ब्लॉक तक गोल किया जाता है)।

इसलिए, अगर मेमोरी ब्लॉक का आकार भी मिल सकता है, तो यह हमें नहीं बताता है कि नई [] ed मेमोरी में कितने मूल्य हैं, क्योंकि यह छोटा हो सकता है। इसलिए, हमें एक अतिरिक्त पूर्णांक स्टोर करना होगा जो हमें बता रहा है कि कितने मूल्य हैं।

EXCEPT, अगर निर्माण के प्रकार में कोई विनाशक नहीं है, तो हटाएं [] को मेमोरी ब्लॉक को छोड़कर कुछ भी करने की ज़रूरत नहीं है, और इसलिए कुछ भी स्टोर नहीं करना है!