C ++ 11 में अपवादों के साथ काम करने में नया क्या है

इंटरनेट पर, वे C ++ 11 की नई सुविधाओं के बारे में बहुत सारी बातें करते हैं: ऑटो, लैम्ब्डा, वेरैडिक टेम्प्लेट। लेकिन किसी तरह हमने अपवादों के साथ काम करने के नए अवसरों को दरकिनार कर दिया जो भाषा और मानक पुस्तकालय प्रदान करते हैं।

मानक के पिछले संस्करण से, अपवादों को फेंकने (फेंकने) के लिए एक तंत्र छोड़ दिया गया था, यह देखते हुए कि हम अपवाद को संभालने की प्रक्रिया में हैं (std :: uncaught_exception), एक रोक तंत्र यदि अपवाद को संभाला नहीं गया है। एसटीडी :: अपवाद वर्ग के आधार पर मानक अपवादों का एक पदानुक्रम भी है।

नया मानक इन चीजों में कुछ और इकाइयाँ जोड़ता है, जो मेरी राय में, C ++ में अपवादों के साथ काम को बहुत सरल कर सकते हैं।

exception_ptr

तो, सबसे पहली चीज जिसका हम सामना कर सकते हैं वह है std :: अपवाद_ptr। यह प्रकार आपको किसी भी प्रकार के अपवाद को संग्रहीत करने की अनुमति देता है। मानक निर्दिष्ट नहीं करता है कि यह प्रकार कैसे प्राप्त किया जाता है। यह एक टंकण हो सकता है, यह एक वर्ग का कार्यान्वयन हो सकता है। इसका व्यवहार std :: shared_ptr के व्यवहार के समान है, अर्थात, इसे कॉपी किया जा सकता है, पैरामीटर के रूप में पास किया जाता है, जबकि अपवाद स्वयं कॉपी नहीं किया जाता है। अपवाद पैरामीटर का मुख्य उद्देश्य फ़ंक्शन मापदंडों के रूप में अपवाद भेजना है; थ्रेड्स के बीच अपवादों को पारित करना संभव है। इस प्रकार, इस प्रकार की वस्तुएं त्रुटि को अधिक लचीला बना देती हैं:

struct some_exception { explicit some_exception(int x): v(x) { std::cout << " int ctor" << std::endl; } some_exception(const some_exception & e): v(ev) { std::cout << " copy ctor" << std::endl; } int v; }; std::exception_ptr throwExceptionAndCaptureExceptionPtr() { std::exception_ptr currentException; try { const int throwValue = 10; std::cout << "throwing " << throwValue << "..." << std::endl; throw some_exception(throwValue); } catch (...) { currentException = std::current_exception(); } return currentException; } void rethrowException(std::exception_ptr ePtr) { try { if (ePtr) { std::rethrow_exception(ePtr); } } catch (const some_exception & e) { std::cout << "catched int value: " << ev << std::endl; } std::exception_ptr anotherExceptionPtr = ePtr; try { if (anotherExceptionPtr) { std::rethrow_exception(anotherExceptionPtr); } } catch (const some_exception & e) { std::cout << "catched int value: " << ev << std::endl; } } void checkMakeExceptionPtr() { std::exception_ptr currentException = std::make_exception_ptr(some_exception(20)); std::cout << "exception_ptr constructed" << std::endl; rethrowException(currentException); } void exceptionPtrSample() { rethrowException(throwExceptionAndCaptureExceptionPtr()); checkMakeExceptionPtr(); } 

यदि हम निष्पादन के लिए अपवाद PtrSample फ़ंक्शन चलाते हैं, तो हम निम्नलिखित की तरह कुछ देखेंगे:

10 फेंक रहे हैं ...
int ctor
पकड़ा गया अंतर मान: 10
पकड़ा गया अंतर मान: 10
int ctor
नकल करनेवाला
नकल करनेवाला
अपवाद_पट का निर्माण
पकड़े गए इंट वैल्यू: 20
पकड़े गए इंट वैल्यू: 20

अपवाद_पट के साथ आसानी से काम करने में सक्षम होने के लिए, कई सहायक कार्य हैं:

• current_exception - यह फ़ंक्शन अपवाद_ptr लौटाता है। यदि हम कैच ब्लॉक के अंदर हैं, तो यह अपवाद_ptr को लौटाता है, जिसमें वर्तमान स्क्रैप द्वारा संसाधित किया जा रहा अपवाद शामिल है; यदि आप इसे कैच ब्लॉक के बाहर कहते हैं, तो यह एक खाली अपवाद_ptr ऑब्जेक्ट लौटा देगा
• rethrow_exception - यह फ़ंक्शन एक अपवाद फेंकता है, जो अपवाद_ptr में समाहित है। यदि इनपुट पैरामीटर में अपवाद (खाली ऑब्जेक्ट) नहीं है, तो परिणाम अपरिभाषित है। इस स्थिति में, msvc std :: bad_exception को फेंक देता है , और gcc-4.7.2 के साथ संकलित कार्यक्रम अप्रत्याशित रूप से समाप्त हो जाता है ।
• make_exception_ptr - यह फ़ंक्शन बिना किसी अपवाद को छोड़ अपवाद_ptr का निर्माण कर सकता है। इसका उद्देश्य फ़ंक्शन std :: make_sared - किसी ऑब्जेक्ट का निर्माण करने के समान है। इसका निष्‍पादन फंक्‍शन के प्रकार है। Gcc-4.7.2 के कार्यान्वयन में, make_exception_ptr, some_exception object की दो प्रतियाँ बनाती है।

धागे के बीच अपवादों को पार करना

मुझे ऐसा लगता है कि थ्रेड के बीच अपवादों को पारित करने की समस्या को हल करने के लिए विशेष रूप से अपवाद_ptr बनाया गया था, तो आइए जानें कि हम एक थ्रेड से दूसरे में अपवाद कैसे पारित कर सकते हैं:

 void worker(std::promise<void> & p) { try { throw std::runtime_error("exception from thread"); } catch (...) { p.set_exception(std::current_exception()); } } void checkThreadAndException() { std::promise<void> p; auto result = p.get_future(); std::thread t(worker, ref(p)); t.detach(); try { result.get(); } catch (const std::runtime_error & e) { std::cout << "runtime error catched from async worker" << std::endl; } } 

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

अलग से, यह gcc-4.7 में मल्टीथ्रेडिंग के उपयोग का उल्लेख करने योग्य है। प्रारंभ में, यह उदाहरण मेरे लिए काम नहीं करता था (अपवाद को फेंकते हुए), इसे Google, मुझे पता चला कि std :: थ्रेड का उपयोग करने के लिए -pthread झंडे को पास करने के लिए आवश्यक है। चूंकि मैं CMake का उपयोग एक बिल्ड सिस्टम के रूप में करता हूं, इसलिए यह कार्य सरल है (विभिन्न प्लेटफार्मों पर gcc का उपयोग करते समय यहां जटिलता उत्पन्न हो सकती है, उदाहरण के लिए, -थ्रेड फ्लैग का उपयोग स्पार्क सोलारिस पर -preadread के बजाय किया जाता है) - एक विशेष थ्रेड्स CMake मॉड्यूल है जिसमें यह समस्या हल होती है :

find_package (आवश्यक सूत्र)
# ...
लक्ष्य_लिंक_ लाइब्रेरी (cxx_exception $ {CMAKE_THREAD_LIBS_INIT})

अपवाद अपवाद हैं

जैसा कि नाम का अर्थ है, यह तंत्र आपको अन्य अपवादों को "संलग्न" करने की अनुमति देता है (जो पहले फेंका जा सकता था) फेंके गए अपवाद को। उदाहरण के लिए, यदि हमारे पास अपवादों की अपनी पदानुक्रम है, तो हम सभी "तृतीय-पक्ष" अपवादों को पकड़ सकते हैं, उन्हें हमारे अपवादों से जोड़ सकते हैं, और जब हमारे अपवादों को संसाधित करते हैं, तो हम अतिरिक्त प्राप्त कर सकते हैं। ऐसी जानकारी जो उनसे "जुड़ी" है (उदाहरण के लिए, डीबगिंग के दौरान, हम थर्ड-पार्टी अपवादों के बारे में जानकारी प्रिंट कर सकते हैं)। नेस्टेड अपवाद का उपयोग करने का एक अच्छा उदाहरण cppreference.com पर दिया गया है, मेरा उदाहरण इसके साथ आंशिक रूप से ओवरलैप करता है:

 struct third_party_exception { explicit third_party_exception(int e) : code(e) { } int code; }; void third_party_worker() { throw third_party_exception(100); } class our_exception : public std::runtime_error { public: our_exception(const std::string & e) : std::runtime_error("our error: " + e) { } }; void ourWorker() { try { third_party_worker(); } catch (...) { throw_with_nested(our_exception("worker failed")); } } void exceptionHandler(const our_exception & e, bool catchNested) { std::cerr << "our exception catched: " << e.what(); if (catchNested) { try { rethrow_if_nested(e); } catch (const third_party_exception & e) { std::cerr << ", low level reason is: " << e.code; } } std::cerr << std::endl; } void exceptionProcessing() { try { ourWorker(); } catch (const our_exception & e) { exceptionHandler(e, false); } try { ourWorker(); } catch (const our_exception & e) { exceptionHandler(e, true); } } 

तो, हमारे पास एक थर्ड पार्टी फंक्शन है जो एक अपवाद को फेंकता है, हम एक एडेप्टर लिख सकते हैं जो "थर्ड-पार्टी" अपवादों को पकड़ता है, और उनमें से एक हमारा "अपवाद" बनाता है: थर्ड_पार्टी_वर्कर और हमारा वर्कर क्रमशः "थर्ड-पार्टी" फंक्शन और "हमारे" फंक्शन के रूप में कार्य करते हैं। हम सभी अपवादों को पकड़ते हैं, और फिर हमारे (हमारे_एक्सैसेप्शन) अपवाद को फेंक देते हैं, और एक ही समय में, कुछ (हम, सिद्धांत रूप में, पता नहीं हो सकता है) "थर्ड-पार्टी" अपवाद इसके साथ संलग्न था। उसके बाद, हम पहले से ही अपने अपवादों के साथ काम कर रहे हैं। इसके अलावा, अगर हमें "निचले" स्तर पर क्या हुआ, इसके बारे में अधिक विस्तृत जानकारी की आवश्यकता है, तो हम हमेशा rethrow_if_edested फ़ंक्शन को कॉल कर सकते हैं। यह फ़ंक्शन विश्लेषण करता है कि क्या हुक (नेस्टेड) ​​अपवाद फेंका गया है, और यदि ऐसा है, तो इस नेस्टेड अपवाद को फेंकता है। अपवाद हैंडलर फ़ंक्शन "हमारे" अपवाद को स्वीकार करता है और एक अतिरिक्त ध्वज जो किसी तृतीय-पक्ष अपवाद के बारे में जानकारी के उत्पादन या अनुमति देता है। हम कैच किए गए पैरामीटर को नियंत्रित करके थर्ड-पार्टी अपवादों के आउटपुट को नियंत्रित कर सकते हैं, उदाहरण के लिए, कॉन्फ़िगरेशन फ़ाइल (या रिलीज़, डीबग असेंबली पर निर्भर करता है) से।

नेस्टेड अपवाद के साथ काम करने के लिए, एक वर्ग और दो कार्य हैं:

• nested_exception - यह वर्ग "थैला" वस्तु के साथ "मिक्स" करता है, जब std :: throw_with_nested फ़ंक्शन को कॉल किया जाता है - यह वर्ग आपको नेस्टेड ( npt_ptr ) विधि का उपयोग करके एक नेस्टेड अपवाद ( अपवाद_ptr ) को वापस करने की भी अनुमति देता है। इसके अलावा इस वर्ग में एक पुनर्विचार_निश्चित विधि है जो एक नेस्टेड अपवाद को फेंकता है
• throw_with_nested - यह टेम्प्लेट फ़ंक्शन कुछ प्रकार की वस्तु लेता है (चलो इसे इनपुट टाइप कहते हैं), और उस ऑब्जेक्ट को फेंकता है जो std का एक वंशज है :: nested_exception और हमारे InputType (जीसीसी के कार्यान्वयन में, यह एक ऐसा टेम्पलेट प्रकार है जो nested_exception और InputType से विरासत में प्राप्त होता है)। इस प्रकार, हम अपने प्रकार की एक वस्तु और प्रकार के एक ऑब्जेक्ट को पकड़ सकते हैं nested_exception और उसके बाद ही हमारे प्रकार को nested_ptr विधि से प्राप्त कर सकते हैं
• rethrow_if_nested - यह फ़ंक्शन निर्धारित करता है कि ऑब्जेक्ट में नेस्टेड अपवाद है, और यदि ऐसा है, तो इसे फेंकता है। एक कार्यान्वयन विरासत का निर्धारण करने के लिए डायनेमिक_का उपयोग कर सकता है

सिद्धांत रूप में, नेस्टेड अपवाद तंत्र काफी दिलचस्प है, हालांकि कार्यान्वयन काफी तुच्छ हो सकता है, आप इसे पहले वर्णित कार्यों current_exception और rethrow_exception का उपयोग करके स्वयं कर सकते हैं। समान gcc कार्यान्वयन में, nested_exception वर्ग में एक अपवाद type_ptr का एक फ़ील्ड होता है , जिसे निर्माणकर्ता में current_exception फ़ंक्शन का उपयोग करके प्रारंभ किया जाता है, और rethrow_nested पद्धति कार्यान्वयन केवल rethrow -exception फ़ंक्शन को कॉल करता है।

Noexcept विनिर्देशन

इस तंत्र को एक विस्तारित (और अब अप्रचलित) फेंक () तंत्र के रूप में माना जा सकता है। इसका मुख्य उद्देश्य, पहले की तरह, यह सुनिश्चित करना है कि फ़ंक्शन अपवाद नहीं फेंकता है (यदि गारंटी का उल्लंघन किया गया है, तो std :: समाप्ति को कहा जाता है)।

यह तंत्र पुराने फेंक के समान दो तरीकों से उपयोग किया जाता है ()

 void func() noexcept { //... } 

और एक नए रूप में:

 void func() noexcept(boolean_expression_known_at_compile_time) { //... } 

इसके अलावा, यदि अभिव्यक्ति के मूल्य को सच माना जाता है, तो फ़ंक्शन को noexcept के रूप में चिह्नित किया जाता है, अन्यथा, ऐसी कोई गारंटी नहीं है।
संबंधित नॉइसेसेप्ट (अभिव्यक्ति) ऑपरेटर भी है, जिसे संकलित समय पर भी निष्पादित किया जाता है, यदि अभिव्यक्ति अपवाद नहीं छोड़ती है, तो यह ऑपरेटर सही हो जाता है:

 void noexceptSample() { cout << "noexcept int(): " << noexcept(int()) << endl; cout << "noexcept vector<int>(): " << noexcept(vector<int>()) << endl; } 

Gcc-4.7.2 डिस्प्ले के लिए यह कोड:

noexcept int (): 1
noexcept वेक्टर <int> (): 0

यहां हम देखते हैं कि इंट के निर्माता एक अपवाद को नहीं फेंकते हैं, और वेक्टर का निर्माता फेंक सकता है (noexcept के रूप में चिह्नित नहीं)।
यह टेम्पलेट मेटाप्रोग्रामिंग में उपयोग करने के लिए सुविधाजनक है, इस ऑपरेटर का उपयोग करके हम एक टेम्पलेट फ़ंक्शन लिख सकते हैं, जो टेम्पलेट पैरामीटर के आधार पर, noexcept या नहीं के रूप में चिह्नित किया जा सकता है:

 template <typename InputTypeT> void func() noexcept(noexcept(InputTypeT())) { InputTypeT var; /// do smth with var std::cout << "func called, object size: " << sizeof(var) << std::endl; } void noexceptSample() { std::cout << "noexcept int(): " << noexcept(int()) << std::endl; std::cout << "noexcept vector<int>(): " << noexcept(std::vector<int>()) << std::endl << std::endl; /// @note function is not actually called std::cout << "noexcept func<int>: " << noexcept(func<int>()) << std::endl; std::cout << "noexcept func<vector<int>>: " << noexcept(func<std::vector<int>>()) << std::endl; } 

यह उदाहरण आउटपुट:

noexcept int (): 1
noexcept वेक्टर <int> (): 0

noexcept func <int>: 1
noexcept func <वेक्टर <int >>: 0

सारांश

C ++ 11 मानक त्रुटि से निपटने के लिए बहुत कुछ लाया है, ज़ाहिर है, यहां प्रमुख विशेषता अपवाद_ptr है और नियमित वस्तुओं के रूप में मनमाना अपवादों को पारित करने की क्षमता है (फ़ंक्शन में, थ्रेड के बीच अपवाद छोड़ दें)। पहले, प्रत्येक थ्रेड में मुझे एक ब्रांडी ट्राई लिखना था ... सभी अपवादों को पकड़ना था, और यह कार्यक्षमता ट्राई ... कैच कोड की मात्रा को काफी कम कर देती है।

नेस्टेड अपवादों को बनाना भी संभव था, सिद्धांत रूप में, बूस्ट लाइब्रेरी में एक बढ़ावा :: अपवाद तंत्र है जो आपको ऑब्जेक्ट के लिए मनमाना डेटा संलग्न करने की अनुमति देता है (उदाहरण के लिए, त्रुटि कोड, आपके संदेश, आदि), लेकिन यह अन्य समस्याओं को हल करता है - अपवाद के अंदर मध्यस्थता डेटा पास करना।

और अंत में, उन लोगों के लिए जिन्हें गारंटी की आवश्यकता है कि कोड एक अपवाद नहीं फेंकेंगे , नोएक्ससेप्ट है , विशेष रूप से, मानक पुस्तकालय के कई हिस्से इस तंत्र का उपयोग करते हैं।

हमेशा की तरह, सभी उदाहरण github पर पोस्ट किए गए हैं

अद्यतन 1. नेमस्पेस std का उपयोग करके उदाहरणों से हटाया गया, अब आप देख सकते हैं कि कौन सी संस्थाएँ मानक पुस्तकालय से संबंधित हैं और कौन सी नहीं।