सी एक अपवाद पकड़ में पकड़ा (...)

Question

मैं एक अपवाद

catch(...) 

ब्लॉक द्वारा पकड़ा के विवरण प्राप्त कर सकते हैं ब्लॉक का वर्णन मिलता है ++? कुछ .what() std :: अपवाद।

Answer 1

वहाँ एक चाल आप उपयोग करने में सक्षम हो सकता है:

catch(...) { 
    handle_exception(); 
} 

void handle_exception() { 
    try { 
     throw; 
    } catch (const std::exception &e) { 
     std::cout << e.what() << "\n"; 
    } catch (const int i) { 
     std::cout << i << "\n"; 
    } catch (const long l) { 
     std::cout << l << "\n"; 
    } catch (const char *p) { 
     std::cout << p << "\n"; 
    } catch (...) { 
     std::cout << "nope, sorry, I really have no clue what that is\n"; 
    } 

और इतने पर, के रूप में कई अलग अलग प्रकार के लिए के रूप में आपको लगता है फेंक दिया जा सकता है। यदि आपको वास्तव में कुछ भी नहीं पता कि क्या फेंक दिया जा सकता है, तो दूसरा भी आखिरी वाला गलत है, क्योंकि कोई char* फेंक सकता है जो एक नल-टर्मिनेटेड स्ट्रिंग को इंगित नहीं करता है।

यह आमतौर पर std::exception या व्युत्पन्न कक्षा नहीं है जो कुछ भी फेंकना एक बुरा विचार है। std::exception कारण मौजूद है कि सभी को वस्तुओं को फेंकने और पकड़ने दें ताकि वे कुछ उपयोगी कर सकें। एक खिलौना कार्यक्रम में जहां आप वहां से बाहर निकलना चाहते हैं और मानक हेडर को शामिल करने के लिए भी परेशान नहीं किया जा सकता है, ठीक है, शायद int या स्ट्रिंग अक्षर को फेंक दें। मुझे नहीं लगता कि मैं औपचारिक इंटरफ़ेस का वह हिस्सा बनाउंगा। आपके द्वारा फेंकने वाले किसी भी अपवाद आपके औपचारिक इंटरफेस का हिस्सा हैं, भले ही आप उन्हें दस्तावेज करना भूल गए हों।

Answer 2

वह ब्लॉक एक int, या एक const char *, या कुछ भी पकड़ सकता है। संकलक संभवतः कुछ कैसे वर्णन कर सकता है जब यह इसके बारे में कुछ नहीं जानता? अगर आप अपवाद से जानकारी प्राप्त करना चाहते हैं, तो आपको इस प्रकार का पता होना चाहिए।

Answer 3

क्या आप जानते हैं कि आप केवल std :: अपवाद या उपवर्गों फेंक, तो,

catch(std::exception& e) {...e.what()... } 

अन्यथा कोशिश के रूप में DeadMG लिखा था, जब से तुम (लगभग) सब कुछ फेंक कर सकते हैं, आप क्या पकड़ा बारे में कुछ भी कल्पना नहीं कर सकते।

सामान्य रूप से पकड़ (...) बुरी तरह लिखित या दस्तावेजी बाहरी पुस्तकालयों का उपयोग करते समय अंतिम रक्षा के रूप में उपयोग किया जाना चाहिए। तो अगर आप एक पदानुक्रम

catch(my::specialException& e) { 
     // I know what happened and can handle it 
     ... handle special case 
     } 
catch(my::otherSpecialException& e) { 
     // I know what happened and can handle it 
     ... handle other special case 
     } 
catch(std::exception& e) { 
     //I can at least do something with it 
     logger.out(e.what()); 
     } 
catch(...) { 
    // something happened that should not have 
    logger.out("oops"); 
    } 

Answer 4

हम अपने अपवादों को लागू किया है का प्रयोग करेंगे कि, हम अपने अपवाद कक्षाएं, कि सभी std::exception से प्राप्त कर रहे ..

हमारे अपवाद अपवाद संदेश में शामिल होंगे है, समारोह है नाम, फ़ाइल का नाम और रेखा जहां अपवाद उत्पन्न होते हैं। ये सभी संदेश दिखाने के लिए उपयोगी नहीं हैं बल्कि लॉगिंग के लिए भी उपयोग किए जा सकते हैं जो अपवाद को आसानी से निदान करने में मदद करता है। इसलिए, हमें उत्पन्न अपवादों के बारे में पूरी जानकारी मिलती है।

याद रखें कि गलत होने के बारे में जानकारी प्राप्त करने के लिए हमें के लिए अपवाद हैं। तो, जानकारी के हर बिट इस संबंध में मदद करता है ..

Answer 5

सी ++ 11 के बाद से आप एक सूचक के साथ वर्तमान अपवाद पर कब्जा कर सकते हैं:

std::exception_ptr p;  // default initialization is to nullptr 

try { 
     throw 7; 
} 
catch(...) 
{ 
    p = std::current_exception(); 
} 

यह एक स्मार्ट सूचक की तरह बर्ताव करता; जब तक अपवाद वस्तु को इंगित करने वाले कम से कम एक पॉइंटर होता है तो यह नष्ट नहीं होता है।

बाद में (शायद यह भी एक अलग समारोह में) आप वर्तमान शीर्ष जवाब देने के लिए एक समान तरीके से कार्रवाई कर सकते हैं:

try { 
    if (p) 
     std::rethrow_exception(p); 
} 
catch(int x) 
{ 

} 
catch(std::exception &y) 
{ 
} 

Answer 6

का हवाला देते हुए bobah

#include <iostream> 

#include <exception> 
#include <typeinfo> 
#include <stdexcept> 

int main() 
{ 
    try { 
     throw ...; // throw something 
    } 
    catch(...) 
    { 
     std::exception_ptr p = std::current_exception(); 
     std::clog <<(p ? p.__cxa_exception_type()->name() : "null") << std::endl; 
    } 
    return 1; 
}