मैं C ++ अपवाद हैंडलिंग तंत्र कैसे काम करता है, इसके बारे में बता रहा हूं। विशेष रूप से, अपवाद ऑब्जेक्ट कहाँ संग्रहीत किया जाता है और इसे पकड़े जाने तक कई स्कोप के माध्यम से कैसे फैलता है? क्या यह किसी वैश्विक क्षेत्र में संग्रहीत है?
चूंकि यह संकलक विशिष्ट हो सकता है इसलिए कोई इसे g ++ संकलक सूट के संदर्भ में समझा सकता है?
जवाबों:
कार्यान्वयन भिन्न हो सकते हैं, लेकिन कुछ बुनियादी विचार हैं जो आवश्यकताओं से अनुसरण करते हैं।
अपवाद ऑब्जेक्ट अपने आप में एक फ़ंक्शन में बनाई गई एक वस्तु है, जो एक कॉलर में नष्ट हो जाती है। इसलिए, यह आमतौर पर स्टैक पर ऑब्जेक्ट बनाने के लिए संभव नहीं है। दूसरी ओर, कई अपवाद वस्तुएं बहुत बड़ी नहीं हैं। एर्गो, एक बना सकता है जैसे कि एक 32 बाइट बफर और अतिप्रवाह ढेर करने के लिए अगर एक बड़ा अपवाद वस्तु वास्तव में आवश्यक है।
नियंत्रण के वास्तविक हस्तांतरण के लिए, दो रणनीतियां मौजूद हैं। स्टैक को खोलने के लिए स्टैक में पर्याप्त जानकारी दर्ज करना है। यह मूल रूप से चलाने और अपवाद संचालकों को नष्ट करने वालों की सूची है जो अपवाद को पकड़ सकते हैं। जब कोई अपवाद होता है, तब तक उन विध्वंसक को निष्पादित करने वाले स्टैक को वापस चलाएं जब तक कि आप एक मिलान पकड़ न लें।
दूसरी रणनीति इस जानकारी को स्टैक के बाहर तालिकाओं में ले जाती है। अब, जब कोई अपवाद होता है, तो कॉल स्टैक का उपयोग यह पता लगाने के लिए किया जाता है कि कौन से स्कोप दर्ज किए गए हैं लेकिन बाहर नहीं निकले। फिर स्थिर तालिकाओं में देखा जाता है कि यह निर्धारित करने के लिए कि फेंके गए अपवाद को कहां संभाला जाएगा, और बीच में कौन से विध्वंसक चलते हैं। इसका मतलब है कि स्टैक पर ओवरहेड कम अपवाद है; रिटर्न पते वैसे भी आवश्यक हैं। टेबल अतिरिक्त डेटा हैं, लेकिन कंपाइलर उन्हें प्रोग्राम के एक मांग-भार वाले सेगमेंट में डाल सकते हैं।
free()या fclose()कुछ शायद ही कभी इस्तेमाल किए गए कोड पथ में गायब हैं ।
इसे 15.1 में परिभाषित किया गया है जो मानक का अपवाद है।
फेंक एक अस्थायी वस्तु बनाता है।
इस अस्थायी ऑब्जेक्ट के लिए मेमोरी कैसे आवंटित की जाती है अनिर्दिष्ट है।
अस्थायी ऑब्जेक्ट के निर्माण के बाद कॉल स्टैक में निकटतम हैंडलर को पास किया जाता है। थ्रो और कैच पॉइंट के बीच स्टैक को खोलना। जैसा कि स्टैक को खोल दिया गया है किसी भी स्टैक चर को निर्माण के रिवर्स ऑर्डर में नष्ट कर दिया जाता है।
जब तक अपवाद फिर से नहीं फेंका जाता है तब तक अस्थायी हैंडलर के अंत में नष्ट हो जाता है जहां इसे पकड़ा गया था।
नोट: यदि आप संदर्भ द्वारा पकड़ते हैं, तो संदर्भ अस्थायी को संदर्भित करेगा, यदि आप मूल्य से पकड़ते हैं तो अस्थायी वस्तु को मूल्य में कॉपी किया जाता है (और इस प्रकार प्रतिलिपि निर्माता की आवश्यकता होती है)।
S.Meyers से सलाह (कॉन्स्ट रेफरेंस द्वारा कैच)।
try
{
// do stuff
}
catch(MyException const& x)
{
}
catch(std::exception const& x)
{
}
आप यहाँ विस्तृत विवरण के लिए एक नज़र डाल सकते हैं ।
यह सादे सी में उपयोग की जाने वाली चाल पर एक नज़र डालने में भी मदद कर सकता है ताकि कुछ बुनियादी प्रकार के अपवाद हैंडलिंग को लागू किया जा सके। यह निम्नलिखित तरीके से सेटजम्प () और लॉन्गजम्प () का उपयोग करता है: पूर्व अपवाद हैंडलर (जैसे "कैच") को चिह्नित करने के लिए स्टैक को बचाता है, जबकि बाद वाले का उपयोग "मान" करने के लिए किया जाता है। "फेंका गया" मान को ऐसे देखा जाता है जैसे कि उसे किसी फ़ंक्शन से लौटाया गया हो। "Try block" तब समाप्त होता है जब setjmp () को फिर से कॉल किया जाता है या जब फ़ंक्शन वापस आता है।
मुझे पता है कि यह एक पुराना सवाल है, लेकिन एक बहुत अच्छा एक्सपोज़र है, यहाँ gcc और VC में से प्रत्येक में प्रयुक्त दोनों तरीकों को समझाते हुए: http://www.hexblog.com/wp-content/uploads/2012/06/Recon- 2012 Skochinsky-संकलक-Internals.pdf