C++ obtenir la description d'une exception pris des prises (...) bloquer

Question

puis-je obtenir la description d'une exception interceptée par

catch(...) 

bloc? quelque chose comme .what() de std :: exception.

Answer 1

Il y a un truc que vous pourriez être en mesure d'utiliser:

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"; 
    } 

et ainsi de suite, pour autant de types différents que vous pensez peut-être jeté. Si vous ne savez vraiment rien sur ce qui pourrait être jeté, alors même l'avant-dernier est faux, car quelqu'un pourrait lancer un char* qui ne pointe pas vers une chaîne terminée par nul.

Généralement, c'est une mauvaise idée de lancer tout ce qui n'est pas un std::exception ou une classe dérivée. La raison std::exception existe est de permettre à tout le monde de lancer et attraper des objets avec lesquels ils peuvent faire quelque chose d'utile. Dans un programme de jouet où vous voulez juste sortir de là et ne peut même pas être dérangé pour inclure un en-tête standard, OK, peut-être jeter un int ou un littéral de chaîne. Je ne pense pas que je ferais cette partie d'une interface formelle. Toutes les exceptions que vous lancez font partie de votre interface formelle, même si vous avez oublié de les documenter.

Answer 2

Ce bloc peut attraper un int, ou un const char *, ou quoi que ce soit. Comment le compilateur peut-il savoir comment décrire quelque chose alors qu'il n'en sait rien? Si vous souhaitez obtenir des informations sur une exception, vous devez connaître le type.

Answer 3

Si vous savez que vous ne jetez std :: exception ou sous-classes, essayez

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

Sinon, comme l'a écrit DeadMG, puisque vous pouvez jeter (presque) tout, vous ne pouvez pas prendre quoi que ce soit au sujet de ce que vous avez pris.

Normalement, catch (...) ne devrait être utilisé que comme dernier moyen de défense lors de l'utilisation de bibliothèques externes mal écrites ou documentées. Donc, vous devez utiliser une hiérarchie

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

Comment nous avons nos exceptions mises en œuvre est que, nous avons nos propres classes d'exception, qui sont tous dérivés de std::exception ..

Nos exceptions contiendront Message d'exception, fonction nom, nom de fichier et ligne où des exceptions sont générées. Ceux-ci sont tous utiles non seulement pour afficher les messages, mais peut également être utilisé pour la journalisation qui aide à diagnostiquer l'exception assez facilement. Ainsi, nous obtenons toute l'information sur les exceptions générées.

Rappelez-vous les exceptions sont us pour obtenir des informations sur ce qui s'est mal passé. Ainsi, chaque bit d'information aide à cet égard ..

Answer 5

Depuis C++ 11 vous pouvez capturer l'exception actuelle avec un pointeur:

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

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

Ce se comporte comme un pointeur intelligent; tant qu'il y a au moins un pointeur pointant vers l'objet d'exception, il n'est pas détruit.

plus tard (peut-être même dans une autre fonction), vous pouvez prendre des mesures d'une manière similaire à la réponse actuelle haut:

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

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

Answer 6

Citant 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; 
}