विनाशकारी अपवाद

एक बार फिर क्यों विनाशकारी में अपवादों को फेंकना बुरा है

कई सी ++ विशेषज्ञ (उदाहरण के लिए, हर्ब सटर ) हमें सिखाते हैं कि विध्वंसक में अपवाद फेंकना बुरा है, क्योंकि आप पहले से ही फेंके गए एक अपवाद के साथ स्टैक प्रमोशन के दौरान विध्वंसक में मिल सकते हैं, और यदि इस बिंदु पर एक और अपवाद फेंक दिया जाता है, तो std कहा जाएगा :: समाप्त () । इस विषय पर C ++ 17 भाषा मानक (इसके बाद मैं ड्राफ्ट N4713 के स्वतंत्र रूप से उपलब्ध संस्करण का उल्लेख करता हूं ) हमें इस प्रकार बताता है:

18.5.1 std :: समाप्ति () फ़ंक्शन [को छोड़कर

1 कुछ स्थितियों में कम सूक्ष्म त्रुटि हैंडलिंग तकनीकों के लिए अपवाद हैंडलिंग को छोड़ दिया जाना चाहिए। [ध्यान दें:

ये स्थितियां हैं:

...

(1.4) जब स्टैक अनइंडिंग (18.2) के दौरान किसी वस्तु का विनाश एक अपवाद को फेंककर समाप्त होता है, या

...

- अंतिम नोट]

आइए एक सरल उदाहरण पर जाँच करें:

#include <iostream> class PrintInDestructor { public: ~PrintInDestructor() noexcept { std::cerr << "~PrintInDestructor() invoked\n"; } }; void throw_int_func() { std::cerr << "throw_int_func() invoked\n"; throw 1; } class ThrowInDestructor { public: ~ThrowInDestructor() noexcept(false) { std::cerr << "~ThrowInDestructor() invoked\n"; throw_int_func(); } private: PrintInDestructor member_; }; int main(int, char**) { try { ThrowInDestructor bad; throw "BANG!"; } catch (int i) { std::cerr << "Catched int exception: " << i << "\n"; } catch (const char* c) { std::cerr << "Catched const char* exception: " << c << "\n"; } catch (...) { std::cerr << "Catched unknown exception\n"; } return 0; } 

परिणाम:

 ~ThrowInDestructor() invoked throw_int_func() invoked ~PrintInDestructor() invoked terminate called after throwing an instance of 'int' Aborted 

ध्यान दें कि PrintInDestructor विध्वंसक को अभी भी कहा जाता है, अर्थात दूसरा अपवाद फेंकने के बाद, स्टैक पदोन्नति बाधित नहीं होती है। इस विषय पर मानक (वही पैराग्राफ 18.5.1) निम्नलिखित कहता है:

2 ... ऐसी स्थिति में जहां कोई भी मैचिंग हैंडलर नहीं मिलता है,
यह कार्यान्वित-परिभाषित है कि क्या स्टैक :: समाप्ति () कहा जाता है, इससे पहले कि स्टैक निराधार है या नहीं। में
वह स्थिति जहां हैंडलर (18.3) की खोज किसी फ़ंक्शन के सबसे बाहरी ब्लॉक का सामना करती है a
गैर-फेंक अपवाद विनिर्देश (18.4), यह कार्यान्वयन-परिभाषित है कि क्या स्टैक निराधार है,
आंशिक रूप से पूर्ववत करें, या std :: terminate () ...

मैंने जीसीसी (8.2, 7.3) और क्लैंग (6.0, 5.0) के कई संस्करणों पर इस उदाहरण का परीक्षण किया, हर जगह स्टैक का प्रचार जारी है। यदि आप एक संकलक पर आते हैं जहां कार्यान्वयन-परिभाषित अलग है, तो कृपया टिप्पणियों में इसके बारे में लिखें।

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

 class ThrowCatchInDestructor { public: ~ThrowCatchInDestructor() noexcept(false) { try { throw_int_func(); } catch (int i) { std::cerr << "Catched int in ~ThrowCatchInDestructor(): " << i << "\n"; } } private: PrintInDestructor member_; }; int main(int, char**) { try { ThrowCatchInDestructor good; std::cerr << "ThrowCatchInDestructor instance created\n"; throw "BANG!"; } catch (int i) { std::cerr << "Catched int exception: " << i << "\n"; } catch (const char* s) { std::cerr << "Catched const char* exception: " << s << "\n"; } catch (...) { std::cerr << "Catched unknown exception\n"; } return 0; } 

प्रदर्शित करता है

 ThrowCatchInDestructor instance created throw_int_func() invoked Catched int in ~ThrowCatchInDestructor(): 1 ~PrintInDestructor() invoked Catched const char* exception: BANG! 

अप्रिय स्थितियों से कैसे बचें? सिद्धांत रूप में, सब कुछ सरल है: कभी भी विध्वंसक में अपवाद न फेंकें। हालांकि, व्यवहार में यह सरल और सुंदर ढंग से इस सरल आवश्यकता को महसूस करने के लिए इतना सरल नहीं है।

यदि आप नहीं कर सकते, लेकिन वास्तव में चाहते हैं ...

मैं तुरंत ध्यान देता हूं कि मैं विध्वंसक से अपवादों को फेंकने का औचित्य साबित करने की कोशिश नहीं कर रहा हूं, और सटर, मेयर्स और अन्य C ++ गुरुओं का अनुसरण करते हुए, मैं आपसे अनुरोध करता हूं कि आप ऐसा कभी न करें (कम से कम नए कोड में)। फिर भी, वास्तविक अभ्यास में, एक प्रोग्रामर अच्छी तरह से विरासत कोड का सामना कर सकता है, जो उच्च मानकों का नेतृत्व करना इतना आसान नहीं है। इसके अलावा, अक्सर नीचे वर्णित तकनीक डीबगिंग प्रक्रिया में उपयोगी हो सकती है।

उदाहरण के लिए, हम एक रैपर क्लास के साथ एक पुस्तकालय विकसित कर रहे हैं जो एक निश्चित संसाधन के साथ काम को एनकैप्सुलेट करता है। RAII के सिद्धांतों के अनुसार, हम कंस्ट्रक्टर में संसाधन को पकड़ते हैं और इसे विध्वंसक में मुक्त करना चाहिए। लेकिन अगर संसाधन मुक्त करने का प्रयास विफल हो जाए तो क्या होगा? इस समस्या को हल करने के लिए विकल्प:

• त्रुटि को नजरअंदाज करें। बुरा, क्योंकि हम एक ऐसी समस्या को छिपा रहे हैं जो सिस्टम के अन्य हिस्सों को प्रभावित कर सकती है।
• लॉग में लिखें। सिर्फ इसे नजरअंदाज करने से बेहतर है, लेकिन फिर भी बुरा है, क्योंकि हमारी लाइब्रेरी सिस्टम में अपनाई गई लॉगिंग नीतियों के बारे में कुछ भी नहीं जानती है जो इसका उपयोग करती है। मानक लॉग को / dev / null पर पुनर्निर्देशित किया जा सकता है, जिसके परिणामस्वरूप, फिर से, हम एक त्रुटि नहीं देखेंगे।
• संसाधन को एक अलग फ़ंक्शन में ले जाएं जो एक मान लौटाता है या एक अपवाद फेंकता है, और वर्ग उपयोगकर्ता को अपने दम पर कॉल करने के लिए मजबूर करता है। यह बुरा है, क्योंकि उपयोगकर्ता ऐसा करना भूल सकता है, और हमें एक संसाधन रिसाव प्राप्त होगा।
• एक अपवाद फेंक दें। सामान्य मामलों में अच्छा है, के रूप में वर्ग उपयोगकर्ता अपवाद को पकड़ सकता है और मानक तरीके से त्रुटि के बारे में जानकारी प्राप्त कर सकता है। स्टैक प्रमोशन के दौरान खराब, जैसा कि std की ओर जाता है :: समाप्ति () ।

यह कैसे समझा जाए कि हम वर्तमान में स्टैक को बढ़ावा देने की प्रक्रिया में हैं या नहीं? C ++ में, इसके लिए एक विशेष फ़ंक्शन std :: unc-0_exception () है । इसकी मदद से, हम एक सामान्य स्थिति में सुरक्षित रूप से एक अपवाद फेंक सकते हैं, या कुछ कम सही कर सकते हैं, लेकिन स्टैक प्रमोशन के दौरान अपवाद फेंकने के लिए अग्रणी नहीं है।

 class ThrowInDestructor { public: ~ThrowInDestructor() noexcept(false) { if (std::uncaught_exception()) { std::cerr << "~ThrowInDestructor() stack unwinding, not throwing\n"; } else { std::cerr << "~ThrowInDestructor() normal case, throwing\n"; throw_int_func(); } } private: PrintInDestructor member_; }; int main(int, char**) { try { ThrowInDestructor normal; std::cerr << "ThrowInDestructor normal destruction\n"; } catch (int i) { std::cerr << "Catched int exception: " << i << "\n"; } try { ThrowInDestructor stack_unwind; std::cerr << "ThrowInDestructor stack unwinding\n"; throw "BANG!"; } catch (int i) { std::cerr << "Catched int exception: " << i << "\n"; } catch (const char* s) { std::cerr << "Catched const char* exception: " << s << "\n"; } catch (...) { std::cerr << "Catched unknown exception\n"; } return 0; } 

परिणाम:

 ThrowInDestructor normal destruction ~ThrowInDestructor() normal case, throwing throw_int_func() invoked ~PrintInDestructor() invoked Catched int exception: 1 ThrowInDestructor stack unwinding ~ThrowInDestructor() stack unwinding, not throwing ~PrintInDestructor() invoked Catched const char* exception: BANG! 

ध्यान दें कि std :: uncaught_exception () फ़ंक्शन C ++ मानक 17 के बाद से हटा दिया गया है, इसलिए, उदाहरण संकलित करने के लिए, संबंधित vorning को दबाया जाना है ( लेख से उदाहरणों के साथ भंडार देखें )।

इस फ़ंक्शन के साथ समस्या यह है कि यह जांचता है कि क्या हम स्टैक को कताई करने की प्रक्रिया में हैं या नहीं। लेकिन यह समझना असंभव है कि क्या स्टैक प्रमोशन की प्रक्रिया के दौरान वर्तमान विध्वंसक को बुलाया जाता है। नतीजतन, अगर कोई स्टैक प्रमोशन है, लेकिन किसी वस्तु के विनाशकर्ता को सामान्य रूप से कहा जाता है, तो std :: unc-0_exception () अभी भी सही लौटेगा।

 class MayThrowInDestructor { public: ~MayThrowInDestructor() noexcept(false) { if (std::uncaught_exception()) { std::cerr << "~MayThrowInDestructor() stack unwinding, not throwing\n"; } else { std::cerr << "~MayThrowInDestructor() normal case, throwing\n"; throw_int_func(); } } }; class ThrowCatchInDestructor { public: ~ThrowCatchInDestructor() noexcept(false) { try { MayThrowInDestructor may_throw; } catch (int i) { std::cerr << "Catched int in ~ThrowCatchInDestructor(): " << i << "\n"; } } private: PrintInDestructor member_; }; int main(int, char**) { try { ThrowCatchInDestructor stack_unwind; std::cerr << "ThrowInDestructor stack unwinding\n"; throw "BANG!"; } catch (int i) { std::cerr << "Catched int exception: " << i << "\n"; } catch (const char* s) { std::cerr << "Catched const char* exception: " << s << "\n"; } catch (...) { std::cerr << "Catched unknown exception\n"; } return 0; } 

परिणाम:

 ThrowInDestructor stack unwinding ~MayThrowInDestructor() stack unwinding, not throwing ~PrintInDestructor() invoked Catched const char* exception: BANG! 

नए C ++ 17 मानक में, std :: unc-0_exception () फ़ंक्शन को std को बदलने के लिए पेश किया गया था : uncaught_exception () (बहुवचन पर ध्यान दें), जो बूलियन मान के बजाय वर्तमान में सक्रिय अपवादों की संख्या देता है (यहां एक विस्तृत औचित्य है )।

यह कैसे ऊपर वर्णित समस्या को std :: uncaught_exception () के साथ हल किया गया है:

 class MayThrowInDestructor { public: MayThrowInDestructor() : exceptions_(std::uncaught_exceptions()) {} ~MayThrowInDestructor() noexcept(false) { if (std::uncaught_exceptions() > exceptions_) { std::cerr << "~MayThrowInDestructor() stack unwinding, not throwing\n"; } else { std::cerr << "~MayThrowInDestructor() normal case, throwing\n"; throw_int_func(); } } private: int exceptions_; }; class ThrowCatchInDestructor { public: ~ThrowCatchInDestructor() noexcept(false) { try { MayThrowInDestructor may_throw; } catch (int i) { std::cerr << "Catched int in ~ThrowCatchInDestructor(): " << i << "\n"; } } private: PrintInDestructor member_; }; int main(int, char**) { try { ThrowCatchInDestructor stack_unwind; std::cerr << "ThrowInDestructor stack unwinding\n"; throw "BANG!"; } catch (int i) { std::cerr << "Catched int exception: " << i << "\n"; } catch (const char* s) { std::cerr << "Catched const char* exception: " << s << "\n"; } catch (...) { std::cerr << "Catched unknown exception\n"; } return 0; } 

परिणाम:

 ThrowInDestructor stack unwinding ~MayThrowInDestructor() normal case, throwing throw_int_func() invoked Catched int in ~ThrowCatchInDestructor(): 1 ~PrintInDestructor() invoked Catched const char* exception: BANG! 

जब मैं वास्तव में, वास्तव में एक बार में कुछ अपवादों को फेंकना चाहता हूं

std :: uncaught_exception () कॉलिंग से बचा जाता है std :: समाप्त () , लेकिन कई अपवादों को सही ढंग से संभालने में मदद नहीं करता है। आदर्श रूप से, मैं एक ऐसा तंत्र रखना चाहूंगा जो मुझे सभी फेंके गए अपवादों को बचाने की अनुमति देगा, और फिर उन्हें एक स्थान पर संसाधित करेगा।

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

विचार का सार अपवादों को पकड़ना और उन्हें एक कंटेनर में सहेजना है, और फिर उन्हें एक बार में प्राप्त करना और संसाधित करना है। अपवाद ऑब्जेक्ट्स को सहेजने के लिए, C ++ में एक विशेष प्रकार का std :: अपवाद_ptr है । मानक में प्रकार की संरचना का खुलासा नहीं किया गया है, लेकिन यह कहा जाता है कि यह अनिवार्य रूप से प्रति अपवाद वस्तु के लिए साझा किया गया है।

फिर इन अपवादों को संसाधित करने के लिए कैसे? इसके लिए एक फ़ंक्शन std :: rethrow_exception () है , जो एक पॉइंटर std :: अपवाद_ptr लेता है और संबंधित अपवाद फेंकता है। हमें केवल इसे संबंधित कैच सेक्शन के साथ पकड़ना होगा और इसे प्रोसेस करना होगा, जिसके बाद हम अगले अपवाद ऑब्जेक्ट पर जा सकते हैं।

 using exceptions_queue = std::stack<std::exception_ptr>; // Get exceptions queue for current thread exceptions_queue& get_queue() { thread_local exceptions_queue queue_; return queue_; } // Invoke functor and save exception in queue void safe_invoke(std::function<void()> f) noexcept { try { f(); } catch (...) { get_queue().push(std::current_exception()); } } class ThrowInDestructor { public: ~ThrowInDestructor() noexcept { std::cerr << "~ThrowInDestructor() invoked\n"; safe_invoke([]() { throw_int_func(); }); } private: PrintInDestructor member_; }; int main(int, char**) { safe_invoke([]() { ThrowInDestructor bad; throw "BANG!"; }); auto& q = get_queue(); while (!q.empty()) { try { std::exception_ptr ex = q.top(); q.pop(); if (ex != nullptr) { std::rethrow_exception(ex); } } catch (int i) { std::cerr << "Catched int exception: " << i << "\n"; } catch (const char* s) { std::cerr << "Catched const char* exception: " << s << "\n"; } catch (...) { std::cerr << "Catched unknown exception\n"; } } return 0; } 

परिणाम:

 ~ThrowInDestructor() invoked throw_int_func() invoked ~PrintInDestructor() invoked Catched const char* exception: BANG! Catched int exception: 1 

ऊपर दिए गए उदाहरण में, स्टैक का उपयोग अपवाद वस्तुओं को बचाने के लिए किया जाता है, हालांकि, अपवाद हैंडलिंग FIFO सिद्धांत के अनुसार किया जाएगा (अर्थात, तार्किक रूप से यह कतार है - पहले फेंका गया अपवाद संसाधित होने वाला पहला होगा)।

निष्कर्ष

ऑब्जेक्ट डिस्ट्रक्टर्स में अपवादों को फेंकना वास्तव में एक बुरा विचार है, और किसी भी नए कोड में मैं दृढ़ता से noexcept डिस्ट्रक्टर्स घोषित करके ऐसा नहीं करने की सलाह देता हूं। हालांकि, विरासत-संहिता के समर्थन और डिबगिंग के साथ, विध्वंसक से फेंके गए अपवादों को सही ढंग से संभालने की आवश्यकता हो सकती है, जिसमें स्टैक प्रमोशन के दौरान भी शामिल है, और आधुनिक सी ++ हमें इसके लिए तंत्र प्रदान करता है। मुझे उम्मीद है कि लेख में प्रस्तुत विचार इस कठिन रास्ते पर आपकी मदद करेंगे।

संदर्भ

लेख से उदाहरण के साथ भंडार