C++ unbehandelte Ausnahmen

Question

Bietet C++ eine Möglichkeit, etwas visuelles anzuzeigen, wenn eine unbehandelte Ausnahme auftritt?

Was ich tun möchte, ist so etwas wie assert(unhandled exception.msg()) zu machen, wenn es tatsächlich passiert (wie im folgenden Beispiel):

void foo() { 
    throw std::exception("Message!"); 
} 

int main() { 
foo(); 
} 

Ich erwarte, dass diese Art von Code nicht sofort zu beenden (weil Ausnahme nicht behandelte war), zeigen Sie lieber benutzerdefinierte Zusicherung Nachricht (Message! tatsächlich).

Ist das möglich?

Answer 1

Es gibt keinen Weg durch den Standard spezifiziert die Nachricht tatsächlich von der nicht erfassten Ausnahme angezeigt werden soll. Auf vielen Plattformen ist es jedoch trotzdem möglich. Unter Windows können Sie SetUnhandledExceptionFilter verwenden und die C++ - Ausnahmebedingung extrahieren.Mit g ++ (entsprechenden Versionen sowieso) kann die beenden Handler die abgefangene Ausnahme mit Code zugreifen wie:

void terminate_handler() 
    { 
     try { throw; } 
     catch(const std::exception& e) { log(e.what()); } 
     catch(...) {} 
    } 

und in der Tat g ++ 's Standard beenden Handler tun etwas ähnlich. Sie können den Terminierungshandler mit set_terminate setzen.

Kurz gesagt, es gibt keine generische C++ Möglichkeit, aber es gibt Möglichkeiten, die von Ihrer Plattform abhängen.

Answer 2

Wenn ich Ihre Frage richtig lese, fragen Sie, ob Sie throw überladen können (indem Sie ihr Standardverhalten ändern), damit es etwas Benutzerdefiniertes tut. Nein, das kannst du nicht.

Edit: da Sie hartnäckig :) sind, ist hier eine schlechte Idee ™:

#include <iostream> 
#include <stdlib.h> 
#include <windows.h> 

void monkey() { 
    throw std::exception("poop!"); 
} 

LONG WINAPI MyUnhandledExceptionFilter(struct _EXCEPTION_POINTERS *lpTopLevelExceptionFilter) { 
    std::cout << "poop was thrown!" << std::endl; 
    return EXCEPTION_EXECUTE_HANDLER; 
    } 

int main() { 
    SetUnhandledExceptionFilter(&MyUnhandledExceptionFilter); 
    monkey(); 
    return 1; 
} 

Auch dies ist eine sehr schlechte Idee, und es ist offensichtlich plattformabhängig, aber es funktioniert.

Answer 3

Microsoft Visual C++ ermöglicht es Ihnen, nicht behandelte C++ - Ausnahmen like this zu haken. Dies ist standard STL behaviour.

Sie legen einen Handler über einen Anruf auf set_terminate fest. Es wird empfohlen, dass Ihr Handler nicht viel arbeitet und dann das Programm beendet, aber ich sehe nicht, warum Sie etwas über eine Assert nicht signalisieren konnten - obwohl Sie nicht auf die Ausnahme zugreifen können, die das Problem verursacht hat.

Answer 4

Wenn Sie Windows verwenden, ist eine gute Bibliothek für die Behandlung nicht behandelter Ausnahmen und Abstürze CrashRpt. Wenn Sie es manuell tun möchten, können Sie auch use the following I wrote in this answer.

Answer 5

denke ich, die Sie von einer Catch-all-Anweisung profitieren würden wie folgt:

int main() { 
try { 
    foo(); 
catch (...) { 
    // Do something with the unhandled exception. 
} 
} 

Answer 6

Ja, das ist möglich. Hier gehen Sie:

#include <iostream> 
#include <exception> 

void foo() 
{ 
    throw std::exception("Message!"); 
} 

int main() 
{ 
    try 
    { 
    foo(); 
    } 
    catch (std::exception& e) 
    { 
    std::cout << "Got exception: " << e.what() << std::endl; 
    } 

    return 0; 
} 

Answer 7

die C++ Standard ist der Handler beenden - wie andere gesagt haben

Wenn Sie nach besserer Rückverfolgbarkeit sind für wirft dann ist es das, was wir tun

Wir haben einen Makro Wurf Das protokolliert den Dateinamen und die Zeilennummer sowie die Nachricht und wirft dann. Es dauert eine varargs Nachricht im printf-Stil.

Throw(proj::FooException, "Fingle %s unable to process bar %d", fingle.c_str(), barNo); 

ich ein nettes Lognachricht

Throw FooException from nargle.cpp:42 Fingle barf is unable to process bar 99 

Answer 8

Wenn Sie wirklich daran interessiert sind, was passiert ist, damit Ihr Programm fehlschlägt, können Sie das Prozessabbild in einem Post-Mortem-Debugger untersuchen. Die genaue Technik variiert ein wenig von OS zu OS, aber der grundlegende Zug besteht darin, zuerst Core-Dumping zu aktivieren und dein Programm mit Debug-Symbolen zu kompilieren. Sobald das Programm abstürzt, wird das Betriebssystem seinen Speicher auf die Festplatte kopieren, und Sie können dann den Status des Programms zum Zeitpunkt des Absturzes untersuchen.