C++ excepciones no controladas

Question

¿Ofrece C++ una forma de 'mostrar' algo visual si ocurre una excepción no controlada?

Lo que quiero hacer es algo así como assert(unhandled exception.msg()) si realmente ocurre (como en el siguiente ejemplo):

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

int main() { 
foo(); 
} 

me esperaba este tipo de código de no terminar inmediatamente (debido a excepción fue controlada), más bien muestra un mensaje de aserción personalizado (Message! en realidad).

¿Es esto posible?

Answer 1

No hay manera especificada por el estándar de hecho para mostrar el mensaje de la excepción no detectada. Sin embargo, en muchas plataformas, es posible de todos modos. En Windows, puede usar SetUnhandledExceptionFilter y extraer la información de excepción de C++.Con g ++ (versiones adecuadas de todos modos), el manejador de terminar puede acceder a la excepción no detectada con un código como:

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

y de hecho g ++ 's por defecto por terminado controlador hace algo similar a esto. Puede configurar el manejador de terminación con set_terminate.

En resumen, no, no hay una forma genérica de C++, pero hay formas que dependen de su plataforma.

Answer 2

Si estoy leyendo su pregunta correctamente, está preguntando si puede sobrecargar throw (cambiando su comportamiento predeterminado) por lo que hace algo definido por el usuario. No, no puedes.

edición: ya que eres insistente :), aquí es una mala idea ™:

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

Una vez más, esta es una muy mala idea, y es obviamente dependiente de la plataforma, pero funciona.

Answer 3

Microsoft Visual C++ le permite enganchar excepciones de C++ no controladas like this. Esto es standard STL behaviour.

Establece un controlador a través de una llamada al set_terminate. Se recomienda que su controlador no funcione mucho y luego finalice el programa, pero no veo por qué no podría señalar algo a través de una afirmación, aunque no tiene acceso a la excepción que causó el problema.

Answer 4

Si está utilizando Windows, una buena biblioteca para manejar excepciones y bloqueos no controlados es CrashRpt. Si desea hacerlo manualmente, también puede use the following I wrote in this answer.

Answer 5

creo que se beneficiaría de un cajón de sastre declaración de la siguiente manera:

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

Answer 6

Sí, es posible. Aquí van:

#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

El estándar de C++ es el manejador de terminar - como otros han dicho

Si usted está después de una mejor rastreabilidad de los tiros, entonces esto es lo que hacemos

Tenemos un tiro macro que registra el nombre y el número de línea y el mensaje, y luego los arroja. Se necesita un mensaje varargs de estilo printf.

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

me dan un buen mensaje de registro

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

Answer 8

Si está realmente interesado en qué sucedió para hacer que su programa falle, puede beneficiarse examinando la imagen del proceso en un depurador post mortem. La técnica precisa varía un poco del sistema operativo al sistema operativo, pero el tren básico es primero habilitar el dumping central y compilar su programa con símbolos de depuración. Una vez que el programa falla, el sistema operativo copiará su memoria en el disco y luego podrá examinar el estado del programa en el momento en que se bloqueó.