खतरनाक संदर्भ द्वारा अपवाद को पकड़ रहा है?

Question

कृपया निम्न अपवाद फेंकने पर एक नज़र डालें और पकड़ने:

void some_function() { 
    throw std::exception("some error message"); 
} 

int main(int argc, char **argv) { 
    try { 
     some_function(); 
    } catch (const std::exception& e) { 
     std::cerr << e.what() << std::endl; 
     exit(1); 
    } 
    return 0; 
} 

यह संदर्भ द्वारा फेंका अपवाद को पकड़ने के लिए सुरक्षित है?

मेरी चिंता का विषय है क्योंकि अपवाद e वास्तव में ढेर some_function() की पर रखा गया है। लेकिन some_function() अभी वापस आ गया है, जिससे e को नष्ट किया जा सकता है। तो वास्तव में अब एक विनाशकारी वस्तु के लिए e अंक।

क्या मेरी चिंता सही है?

अपवाद को मूल्य के बिना कॉपी किए बिना सही तरीका क्या है? क्या मुझे new std::exception() फेंकना चाहिए ताकि इसे गतिशील स्मृति में रखा जा सके?

Answer 1

यह वास्तव में सुरक्षित है।

"e वास्तव में some_function() के ढेर पर रखा गया है"

कोई यह नहीं है ...वास्तव में फेंक दिया वस्तु स्मृति की एक अनिर्दिष्ट क्षेत्र अपवाद संचालन तंत्र द्वारा उपयोग के लिए आरक्षित में बन जाता है:

[except.throw] 15.1/4: अपवाद वस्तु के लिए स्मृति एक अनिर्दिष्ट में आवंटित किया जाता है जैसा कि 3.7.4.1 में उल्लेख किया गया है। अपवाद ऑब्जेक्ट को नष्ट करने के अलावा किसी अन्य माध्यम से अपवाद के लिए अंतिम शेष सक्रिय हैंडलर के बाद नष्ट हो गया है, या प्रकार की अंतिम वस्तु std :: upgrade_ptr (18.8.5) जो अपवाद वस्तु को संदर्भित करती है, जो भी नष्ट हो जाती है, जो भी हो बाद में है।

एक स्थानीय चर throw को निर्दिष्ट किया जाता है, तो यह की नकल की है वहाँ करने के लिए यदि आवश्यक हो तो (अनुकूलक सीधे इस अन्य स्मृति में बनाने में सक्षम हो सकता है)। इसलिए ...

15,1/5 जब फेंका वस्तु एक वर्ग वस्तु है, निर्माता कॉपी-प्रारंभ और नाशक के लिए चुने गए सुलभ होंगे, भले ही कॉपी/कदम आपरेशन elided है (12.8)।

---

हैं कि उन पर क्लिक नहीं है, यह पराक्रम मदद कार्यान्वयन थोड़ा इस तरह की कल्पना करना:

// implementation support variable... 
thread__local alignas(alignof(std::max_align_t)) 
    char __exception_object[EXCEPTION_OBJECT_BUFFER_SIZE]; 

void some_function() { 
    // throw std::exception("some error message"); 

    // IMPLEMENTATION PSEUDO-CODE: 
    auto&& thrown = std::exception("some error message"); 
    // copy-initialise __exception_object... 
    new (&__exception_object) decltype(thrown){ thrown }; 
    throw __type_of(thrown); 
    // as stack unwinds, _type_of value in register or another 
    // thread_local var... 
} 

int main(int argc, char **argv) 
{ 
    try { 
     some_function(); 
    } // IMPLEMENTATION: 
     // if thrown __type_of for std::exception or derived... 
     catch (const std::exception& e) { 
     // IMPLEMENTATION: 
     // e references *(std::exception*)(&__exception_object[0]); 
     ... 
    } 
} 

Answer 2

कॉन्स्ट संदर्भ द्वारा पकड़ना बिल्कुल कितना अपवाद पकड़ा जाना चाहिए। अपवाद वस्तु जरूरी नहीं है कि 'स्टैक पर' रहें। संकलक इस काम को करने के लिए उपयुक्त जादू के लिए ज़िम्मेदार है।

दूसरी तरफ, आपका उदाहरण संकलित नहीं हो सकता है क्योंकि std::exception केवल डिफ़ॉल्ट-निर्मित या प्रति-निर्मित हो सकता है। इस मामले में what() विधि एक पॉइंटर को खाली (सी-शैली) स्ट्रिंग पर वापस कर देगी, जो विशेष रूप से उपयोगी नहीं है।

आप एक std::runtime_error या std::logic_error के रूप में उपयुक्त फेंक सुझाएँ, या एक वर्ग उससे व्युत्पन्न:

• logic_error जब फोन करने वाले अपनी सेवा के डिजाइन मानकों के बाहर कुछ अनुरोध किया है।
• runtime_error जब कॉलर ने कुछ उचित अनुरोध किया है लेकिन बाहरी कारक आपको अनुरोध का सम्मान करने से रोकते हैं।

http://en.cppreference.com/w/cpp/error/exception

Answer 3

आप , संदर्भ द्वारा पकड़ने के लिए है अन्यथा आप संभवतः वस्तु की सही गतिशील प्रकार प्राप्त नहीं कर सका। अपने जीवनकाल, मानक की गारंटी देता है, [except.throw] में,

अपवाद वस्तु किसी भी rethrowing, या प्रकार एसटीडी के अंतिम वस्तु के अलावा अन्य तरह से अपवाद बाहर निकलता है के लिए या तो अंतिम शेष सक्रिय हैंडलर के बाद नष्ट हो जाता है के रूप में :: और सिफारिश की - - const संदर्भ द्वारा पकड़ने के लिए exception_ptr (18.8.5) है कि अपवाद वस्तु को संदर्भित करता है नष्ट हो जाता है, जो भी बाद

Answer 4

से except.throw:

फेंकने एक अपवाद कॉपी-initializes (8.5, 12.8) एक अस्थायी वस्तु, अपवाद वस्तु कहा जाता है। अस्थायी एक लाभा है और पर मिलान करने वाले हैंडलर (15.3) में घोषित चर को प्रारंभ करने के लिए उपयोग किया जाता है। यदि अपवाद ऑब्जेक्ट का प्रकार अपूर्ण प्रकार या पॉइंटर एक अपूर्ण प्रकार (संभावित रूप से सीवी-योग्य) शून्य के अलावा एक अपूर्ण प्रकार होगा, तो प्रोग्राम खराब हो जाएगा।

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