हटाएं, C ++ में नया [] और उनके संयोजन के बारे में शहरी किंवदंतियों

यदि "नया []" का उपयोग करने वाली वस्तुओं की एक सरणी C ++ कोड में बनाई गई थी, तो आपको "हटाएं"] और "हटाएं" (बिना कोष्ठक) का उपयोग किए किसी भी स्थिति में इस सरणी को हटाने की आवश्यकता नहीं है। एक वाजिब सवाल: ऐसा नहीं है?

इस सवाल के लिए आप अनुचित जवाब की एक विस्तृत श्रृंखला प्राप्त कर सकते हैं। उदाहरण के लिए, "केवल पहली वस्तु हटा दी जाएगी, बाकी सभी लीक हो जाएंगे" या "केवल पहली वस्तु का विनाशकर्ता कहा जाएगा।" निम्नलिखित "स्पष्टीकरण" आमतौर पर किसी भी गंभीर आलोचना के लिए खड़े नहीं होते हैं।

सी ++ मानक के अनुसार, इस स्थिति में व्यवहार को परिभाषित नहीं किया गया है। सभी धारणाएं लोकप्रिय शहरी किंवदंतियों से ज्यादा कुछ नहीं हैं। हम विस्तार से विश्लेषण करेंगे कि क्यों।

हमें एक उदाहरण के साथ एक चालाक योजना की आवश्यकता होगी जो शहरी किंवदंतियों के समर्थकों को प्रभावित करेगी। यहाँ इस तरह के एक हानिरहित ठीक है:

 class Class { public: ~Class() { printf( "Class::~Class()" ); } }; int main() { delete new Class[1]; return 0; } 

सरणी में केवल एक ऑब्जेक्ट है। यदि आप ऊपर के दो किंवदंतियों में से एक मानते हैं, तो "सबकुछ ठीक हो जाएगा" - रिसाव के लिए कुछ भी नहीं है और कहीं भी, विध्वंसक बिल्कुल वैसा ही कहा जाएगा जैसी जरूरत है।

हम codepad.org पर जाते हैं, कोड को फॉर्म में डालते हैं, हम आउटपुट प्राप्त करते हैं:

  स्मृति आवंटित ब्लॉक से पहले बंद हो गई
 निर्गमन: निर्गमन १२F
 42 75 67 20 61 73 73 73 73 73 69 69 6 ई 20 77
 61 6 ई 74 65 64 20 2 डी 20 77 77 77 2 ई 61 62
 62 79 79 2E 72 75 2F 76 61 63 61 6E 63 79

याद है क्या ??? वह क्या था?

दूसरा उदाहरण:

 int main() { delete new char[1]; return 0; } 

जारी करना:

  कोई त्रुटि या प्रोग्राम आउटपुट नहीं। 

यहां, कम से कम उपस्थिति में, सब कुछ ठीक है। क्या चल रहा है? ऐसा क्यों हो रहा है? व्यवहार अलग क्यों लगता है?

कारण वही है जो अंदर होता है।

जब कोड में "नया प्रकार [गिनती]" सामने आता है, तो प्रोग्राम को निर्दिष्ट संख्या की वस्तुओं को संग्रहीत करने के लिए पर्याप्त मेमोरी आवंटित करनी चाहिए। ऐसा करने के लिए, वह फ़ंक्शन "ऑपरेटर नया [] ()" का उपयोग करती है। यह फ़ंक्शन मेमोरी को आवंटित करता है - आम तौर पर सिर्फ मॉलॉक () को कॉल करने और रिटर्न वैल्यू (यदि आवश्यक हो, new_handler को कॉल करना) और (अपवाद फेंकना) की जांच करना। फिर वस्तुओं को आवंटित स्मृति में निर्मित किया जाता है - निर्माणकर्ताओं की आवश्यक संख्या कहा जाता है। "नए प्रकार [गिनती]" का परिणाम सरणी के पहले तत्व का पता है।

जब कोड में "डिलीट [] पॉइंटर" पाया जाता है, तो प्रोग्राम को उनके लिए डिस्ट्रक्टर्स कॉल करके सरणी की सभी वस्तुओं को नष्ट करना होगा। इसके लिए (और केवल इसके लिए) उसे तत्वों की संख्या जानने की जरूरत है।

एक महत्वपूर्ण बिंदु: "नए प्रकार [गिनती]" निर्माण में, तत्वों की संख्या स्पष्ट रूप से निर्दिष्ट की गई थी, और "हटाएं []" केवल पहले तत्व का पता प्राप्त करता है।

कार्यक्रम तत्वों की संख्या कैसे जानता है? चूंकि उसके पास केवल पहले तत्व का पता है, इसलिए उसे अकेले इस पते के आधार पर सरणी की लंबाई की गणना करनी होगी। यह कैसे किया जाता है यह कार्यान्वयन पर निर्भर करता है; आमतौर पर निम्नलिखित विधि का उपयोग किया जाता है।

"नया प्रकार [गिनती]" निष्पादित करते समय, प्रोग्राम इतनी मेमोरी आवंटित करता है कि यह न केवल ऑब्जेक्ट्स पर फिट बैठता है, बल्कि एक अहस्ताक्षरित पूर्णांक (आमतौर पर type size_t), ऑब्जेक्ट्स की संख्या को दर्शाता है। यह संख्या चयनित क्षेत्र की शुरुआत में लिखी जाती है, फिर वस्तुओं को रखा जाता है। संकलक, जब "नया प्रकार [गणना]" संकलित करता है, तो इन सीटी को लागू करने वाले प्रोग्राम में कोड सम्मिलित करता है।

इसलिए, "नया प्रकार [गिनती]" निष्पादित करते समय, प्रोग्राम थोड़ा अधिक मेमोरी आवंटित करता है, आवंटित मेमोरी ब्लॉक की शुरुआत के लिए तत्वों की संख्या लिखता है, निर्माणकर्ताओं को कॉल करता है, और कॉलिंग कोड को पहले तत्व का पता देता है। पहला तत्व का पता मेमोरी आवंटन फ़ंक्शन "ऑपरेटर नया [] ()" द्वारा लौटाए गए पते से अलग होगा।

"डिलीट []] को निष्पादित करते समय, प्रोग्राम" डिलीट []] में दिए गए पहले तत्व का पता लेता है, ब्लॉक की शुरुआत के पते को निर्धारित करता है ("नई []" को निष्पादित करते समय उसी तरह घटाया गया था), ब्लॉक की शुरुआत से तत्वों की संख्या को पढ़ता है। विध्वंसक की आवश्यक संख्या को कॉल करता है, फिर - फ़ंक्शन को "ऑपरेटर डिलीट [] ()" कहता है, इसे ब्लॉक की शुरुआत का पता बताता है।

दोनों मामलों में, कॉलिंग कोड उस पते के साथ काम नहीं करता है जिसे मेमोरी आवंटन फ़ंक्शन द्वारा लौटाया गया था और बाद में मेमोरी डीलॉलेशन फ़ंक्शन को पास किया गया।

अब पहले उदाहरण पर वापस आते हैं। जब "हटाएं" निष्पादित किया जाता है (कोष्ठक के बिना), तो कॉलिंग कोड का कोई पता नहीं है कि आपको पता ऑफसेट के साथ एक अनुक्रम खेलने की आवश्यकता है। सबसे अधिक संभावना है, यह एक एकल ऑब्जेक्ट के विध्वंसक को कॉल करता है, फिर फ़ंक्शन "ऑपरेटर डिलीट ()" से गुजरता है जो एक पता है जो पहले से लौटे फ़ंक्शन "ऑपरेटर नया [] ()" से भिन्न होता है।

क्या होने वाला है? इस कार्यान्वयन में, प्रोग्राम क्रैश हो जाता है। चूंकि मानक कहते हैं कि व्यवहार अपरिभाषित है, यह स्वीकार्य है।

तुलना के लिए, दृश्य C ++ 9 में डिफ़ॉल्ट रूप से प्रोग्राम डिबग संस्करण में त्रुटि संदेशों का उत्सर्जन करता है, लेकिन यह ठीक काम करने लगता है (कम से कम _heapchk) फ़ंक्शन कोड _HEAP_OK, _CrtDumpMemorLeaks () कोई संदेश नहीं देता है) देता है। यह भी स्वीकार्य है।

दूसरे उदाहरण में व्यवहार अलग क्यों है? सबसे अधिक संभावना है, संकलक ने ध्यान दिया कि चार प्रकार में एक तुच्छ विध्वंसक है, अर्थात्। आपको ऑब्जेक्ट्स को नष्ट करने के लिए कुछ भी करने की ज़रूरत नहीं है, लेकिन बस मेमोरी को फ्री करें, इसलिए आपको तत्वों की संख्या को संग्रहीत करने की आवश्यकता नहीं है, जिसका अर्थ है कि आप कॉलिंग कोड को तुरंत वही पता वापस कर सकते हैं जो "ऑपरेटर नया [] ()" फ़ंक्शन लौटा है। कोई पता ऑफ़सेट नहीं - "नया" (कोष्ठक के बिना) कहते समय ठीक वैसा ही। यह संकलक व्यवहार पूरी तरह से मानक के अनुरूप है।

कुछ याद आ रहा है ...

क्या आपने पहले ही देखा है कि पाठ में उच्चतर मेमोरी को आवंटित करने और मुक्त करने के कार्य हैं, या तो वर्ग कोष्ठक के साथ या बिना? ये टाइपोस नहीं हैं - वे दो अलग-अलग कार्य हैं, उन्हें पूरी तरह से अलग तरीके से लागू किया जा सकता है। यहां तक ​​कि जब कंपाइलर पैसे बचाने की कोशिश करता है, तो यह हमेशा ऑपरेटर को [] () फ़ंक्शन को कॉल करता है जब वह कोड में नए प्रकार [गिनती] को देखता है, और यह हमेशा ऑपरेटर को नए () फ़ंक्शन को कॉल करता है जब वह नए प्रकार को कोड में देखता है ।

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

यह अनिश्चित व्यवहार के लिए समृद्ध अवसर प्रदान करता है। यदि आपका कोड "गलत" फ़ंक्शन द्वारा मेमोरी को मुक्त करने का कारण बनता है, तो यह किसी भी परिणाम को जन्म दे सकता है, विशेष रूप से, ढेर को नुकसान, स्मृति भ्रष्टाचार, या तत्काल प्रोग्राम क्रैश। पहले उदाहरण में, "ऑपरेटर डिलीट ()" फंक्शन का क्रियान्वयन उसके पास दिए गए पते का निपटान नहीं कर सका और प्रोग्राम क्रैश हो गया।

इस कहानी का सबसे सुखद हिस्सा यह है कि आप कभी भी यह तर्क नहीं दे सकते हैं कि "डिलीट ["] के बजाय "डिलीट" (और इसके विपरीत, भी) का उपयोग करने से कुछ विशिष्ट परिणाम प्राप्त होते हैं। मानक का कहना है कि व्यवहार अपरिभाषित है। यहां तक ​​कि एक कंपाइलर जो पूरी तरह से मानक के अनुरूप है, आपको किसी भी पर्याप्त व्यवहार के साथ एक कार्यक्रम देने की आवश्यकता नहीं है। कार्यक्रम का व्यवहार जिसे आप टिप्पणियों और विवादों में संदर्भित करेंगे, केवल अवलोकन योग्य है - अंदर कुछ भी हो सकता है। आप केवल आपके द्वारा देखे गए व्यवहार को बताते हैं।

दूसरे उदाहरण में, सब कुछ अच्छा लग रहा है ... इस कार्यान्वयन पर। एक अन्य कार्यान्वयन में, फ़ंक्शन "ऑपरेटर नया ()" और "ऑपरेटर नया [] ("), उदाहरण के लिए, अलग-अलग ढेर पर लागू किया जा सकता है (विंडोज आपको प्रति प्रक्रिया एक से अधिक ढेर बनाने की अनुमति देता है)। जब आप "गलत" हीप को ब्लॉक करने का प्रयास करते हैं तो क्या होता है?

वैसे, इस स्थिति में कुछ विशिष्ट व्यवहार पर भरोसा करते हुए, आपको स्वचालित रूप से एक असहनीय कोड मिलता है। यहां तक ​​कि अगर वर्तमान कार्यान्वयन पर "सब कुछ काम करता है", तो संकलक को बदलते समय, दूसरे संकलक पर स्विच करते समय, या सी ++ रनटाइम को अपडेट करते समय भी, आप बेहद अप्रिय रूप से आश्चर्यचकित हो सकते हैं।

कैसे हो? अपने आप को इस्तीफा दें, "हटाएं" और "हटाएं []" को भ्रमित न करें, और सबसे महत्वपूर्ण बात यह है कि यदि आप उन्हें मिलाते हैं तो क्या होगा, इसका "प्रशंसनीय" स्पष्टीकरण में अपना समय बर्बाद न करें। जब आप तर्क करते हैं, तो अन्य डेवलपर्स कुछ उपयोगी करेंगे, और आपके लिए डार्विन पुरस्कार अर्जित करने की संभावना बढ़ जाएगी।

दिमित्री मेश्चेरीकोव
डेवलपर उत्पाद विभाग