¿Está capturando todas las excepciones de C++ no controladas?

Question

¿Hay alguna manera de detectar excepciones que de lo contrario no se han controlado (incluidas las lanzadas fuera del bloque catch)?

No estoy realmente preocupado por todas las cosas normales de limpieza hechas con excepciones, solo que puedo atraparlo, escribirlo para registrar/notificar al usuario y salir del programa, ya que las excepciones en estos casos son en general fatales, errores irrecuperables.

algo como:

global_catch() 
{ 
    MessageBox(NULL,L"Fatal Error", L"A fatal error has occured. Sorry for any inconvience", MB_ICONERROR); 
    exit(-1); 
} 
global_catch(Exception *except) 
{ 
    MessageBox(NULL,L"Fatal Error", except->ToString(), MB_ICONERROR); 
    exit(-1); 
} 

Answer 1

Esto puede ser usado para capturar, excepciones inesperadas.

Sin un bloque intento de captura, no creo que se puede capturar las excepciones, por lo que la estructura de su programa, por lo que el código de excepción thowing está bajo el control de un try/catch.

Answer 2

Esto es lo que siempre hago en main()

int main() 
{ 
    try 
    { 
     // Do Work 
    } 
    catch(std::exception const& e) 
    { 
     Log(e.what()); 
     // If you are feeling mad (not in main) you could rethrow! 
    } 
    catch(...) 
    { 
     Log("UNKNOWN EXCEPTION"); 
     // If you are feeling mad (not in main) you could rethrow! 
    } 
} 

Answer 3

Puede utilizar SetUnhandledExceptionFilter en Windows, lo que capturar todas las excepciones SEH no controladas.

En general, esto será suficiente para todos sus problemas ya que IIRC todas las excepciones de C++ se implementan como SEH.

Answer 4

Sin ningún bloqueo, no se detectarán excepciones. Puede tener un bloque catch (...) en su main() (y su equivalente en cada thread adicional). En este bloque catch, puede recuperar los detalles de la excepción y puede hacer algo al respecto, como iniciar sesión y salir.

Sin embargo, también hay un inconveniente en un bloque de captura general (...): el sistema determina que la excepción ha sido manejada por usted, por lo que no le da más ayuda. En Unix/Linux, esta ayuda constituiría la creación de un archivo CORE, que podría cargar en el depurador y ver la ubicación original de la excepción no aceptada. Si lo está manejando con catch (...) esta información ya estaría perdida.

En Windows, no hay archivos CORE, por lo que sugeriría tener el bloque catch (...). A partir de ese bloque, lo más habitual es llamar a una función de resucitar la excepción real:

std::string ResurrectException() 
    try { 
     throw; 
    } catch (const std::exception& e) { 
     return e.what(); 
    } catch (your_custom_exception_type& e) { 
     return e.ToString(); 
    } catch(...) { 
     return "Ünknown exception!"; 
    } 
} 


int main() { 
    try { 
     // your code here 
    } catch(...) { 
     std::string message = ResurrectException(); 
     std::cerr << "Fatal exception: " << message << "\n"; 
    } 
} 

Answer 5

actualización: Esto cubre C++ 98 solamente.

A partir de More Effective C++ por Meyers (pg 76), podría definir una función a la que se llama cuando una función genera una excepción que no está definida por su especificación de excepción.

void convertUnexpected() 
{ 
    // You could redefine the exception here into a known exception 
    // throw UnexpectedException(); 

    // ... or I suppose you could log an error and exit. 
} 

En su solicitud de registro de la función:

std::set_unexpected(convertUnexpected); 

Su función convertUnexpected() se llamará si una función genera una excepción que no se define por su especificación de excepción ... que significa esto sólo funciona si está utilizando especificaciones de excepción. ; (

Answer 6

Use catch (...) en todas sus barreras de excepción (no solo en el hilo principal). Sugiero que siempre vuelva a lanzar (...) y redirija la salida/error estándar al archivo de registro, como no puedes hacer RTTI significativo en (...).Otoh, compilador GCC, como es la salida de una descripción bastante detallada sobre la excepción no controlada: el tipo, el valor de lo que(), etc.

Answer 7

Salida std::set_terminate()

Answer 8

A condición de que C++ 11 está disponible, este enfoque puede ser utilizado (véase el ejemplo de: http://en.cppreference.com/w/cpp/error/rethrow_exception):

#include <iostream> 
#include <exception> 

void onterminate() { 
    try { 
    auto unknown = std::current_exception(); 
    if (unknown) { 
     std::rethrow_exception(unknown); 
    } else { 
     std::cerr << "normal termination" << std::endl; 
    } 
    } catch (const std::exception& e) { // for proper `std::` exceptions 
    std::cerr << "unexpected exception: " << e.what() << std::endl; 
    } catch (...) { // last resort for things like `throw 1;` 
    std::cerr << "unknown exception" << std::endl; 
    } 
} 

int main() { 
    std::set_terminate(onterminate); // set custom terminate handler 
    // code which may throw... 
    return 0; 
} 

este enfoque también permite personalizar la salida de la consola para las excepciones no controladas: tener algo como esto

unexpected exception: wrong input parameters 
Aborted 

en lugar de esto:

terminate called after throwing an instance of 'std::logic_error' 
    what(): wrong input parameters 
Aborted