सी ++ - एक पकड़ा डिफ़ॉल्ट अपवाद

Question

के प्रकार खोजने कहो मेरे पास है:

try 
{ 
externalLibrary::doSomething(); 
} 
catch (std::exception &e) 
{ 
//yay I know what to do 
} 
catch (...) 
{ 
//darn, I've no idea what happened! 
} 

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

throw myStupidCustomString("here is some really useful information"); 

लेकिन मैं कभी पता नहीं अगर मैं ...

पकड़ने MSVC++ 2008 अगर यह मायने रखती में कार्य करना चाहते हैं।

Answer 1

क्योंकि सी ++ स्थिर रूप से टाइप किया गया है, तो आपको एक ज्ञात प्रकार को पकड़ना होगा। हालांकि, आप बाहरी फ़ंक्शन (या फ़ंक्शंस सेट) को कॉल कर सकते हैं जो उस बिंदु पर अज्ञात अपवाद प्रकारों को संभालता है जिन्हें आप कॉल करते हैं। यदि इन हैंडलर सभी को ज्ञात प्रकार हैं, तो आप गतिशील रूप से प्रयास करने के लिए उन्हें पंजीकृत कर सकते हैं।

struct myStupidCustomString { 
    myStupidCustomString(char const *what) : what (what) {} 
    char const *what; 
}; 

void throws() { 
    throw myStupidCustomString("here is some really useful information"); 
} 

// The external library can provide a function, or you can provide a wrapper, which 
// extracts information from "unknown" exception types. 
std::string extract_from_unknown_external_exception() { 
    try { throw; } 
    catch (myStupidCustomString &e) { 
    return e.what; 
    } 
    catch (...) { 
    throw; // Rethrow original exception. 
    } 
} 

Use:

void example() { 
    try { throws(); } 
    catch (...) { 
    try { 
     std::string extracted = extract_from_unknown_external_exception(); 
     std::cout << "extracted: " << extracted << '\n'; 
    } 
    catch (...) { 
     // Chain handlers for other types; e.g. exception types from other libraries. 
     // Or do something generic for the unknown exception. 

     // Or rethrow the original unknown exception: 
     throw; 
    } 
    } 
} 

Handler chain:

typedef std::string Extract(); 
std::vector<Extract*> chain (1, &extract_from_unknown_external_exception); 
// Chain would normally be initialized using whatever scheme you prefer for 
// initializing global objects. 
// A list or other container (including a manual linked list that doesn't 
// require dynamic allocation) may be more appropriate, depending on how you 
// want to register and unregister handlers. 
std::string process_chain() { 
    for (std::vector<Extract*>::iterator x = chain.begin(); x != chain.end(); ++x) { 
    try { 
     return (*x)(); 
    } 
    catch (...) {} // That handler couldn't handle it. Proceed to next. 
    } 
    throw; // None could handle it, rethrow original exception. 
} 

void example() { 
    try { throws(); } 
    catch (...) { 
    try { 
     std::string extracted = process_chain(); 
     std::cout << "extracted: " << extracted << '\n'; 
    } 
    catch (...) { 
     throw; // Rethrow unknown exception, or otherwise handle it. 
    } 
    } 
} 

अंत में, यदि आप कार्यान्वयन बारीकियों पता है, तुम उन को निकालने के लिए अपने कार्यान्वयन को उजागर करता है जो कुछ अतिरिक्त जानकारी का उपयोग कर सकते हैं। सी ++ 0 एक्स कुछ पोर्टेबल तरीके से कुछ विनिर्देशों का खुलासा करता है; std :: upgrade_ptr पर देखें।

Answer 2

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

यदि आप भाग्यशाली हैं, तो आप किसी भी डेटा को सहेजने में सक्षम हो सकते हैं।

Answer 3

कोई रास्ता नहीं सी में अपवाद के प्रकार पता करने के लिए ++ (catch(...) ब्लॉक में, मैं cource की मतलब है,)

तुम बस आशा है कि हो सकता है कि आप जानते हैं कि नहीं है वास्तव में क्या externalLibrary::doSomething();, करता है अगर आप इसे लिखा है, या , जैसा कि आपके मामले में, आप उम्मीद कर सकते हैं कि externalLibrary::doSomething(); के लिए वास्तव में अच्छा प्रलेखन है और यदि ऐसा है, तो इसे पढ़ें। सभी अच्छी पुस्तकालयों में विस्तृत दस्तावेज हैं।

Answer 4

यदि आप जीसीसी या क्लैंग का उपयोग करते हैं तो आप 'अज्ञात' अपवाद प्रकार को जानने के लिए एक चाल का उपयोग कर सकते हैं। ध्यान रखें कि यह गैर मानक है!

#include <cstdlib> 
#include <iostream> 
#include <cxxabi.h> 


using namespace __cxxabiv1; 

std::string util_demangle(std::string to_demangle) 
{ 
    int status = 0; 
    char * buff = __cxxabiv1::__cxa_demangle(to_demangle.c_str(), NULL, NULL, &status); 
    std::string demangled = buff; 
    std::free(buff); 
    return demangled; 
} 

struct MyCustomClass 
{}; 

int main(int argc, char * argv[]) 
{ 
    try 
    { 
     throw MyCustomClass(); 
    } 
    catch(...) 
    { 
     std::cout << "\nUnknown exception type: '" << util_demangle(__cxa_current_exception_type()->name()) << "'" << std::endl; 
    } 
    return(0); 
}