Cómo manejar todos los errores, incluidos los errores internos de la biblioteca C, de manera uniforme

Quería manejar todos los errores internos con gracia, sin la terminación del progtwig.

Como se discutió aquí , el uso de _set_se_translator atrapa los errores de división por cero.

Pero no detecta , por ejemplo, el error de biblioteca en tiempo de ejecución C -1073740777 (0xc0000417) , que puede ser causado por cadenas de formato para printf que tienen el signo de porcentaje donde no deberían. (Eso es solo un ejemplo; por supuesto, deberíamos verificar dichas cadenas). Para manejar esto, se necesita _set_invalid_parameter_handler .

Hay alrededor de diez otros manejadores similares listados aquí .

Además, este capturará excepciones de C ++ no detectadas : SetUnhandledExceptionFilter . Por lo tanto, se puede utilizar junto con las funciones __set__ … (Un artículo sobre su uso en MSVC 2008).

Quiero detectar todos y cada uno de los errores para poder manejarlos (al iniciar sesión, lanzar una excepción estándar moderna de C ++ y devolver un código de error específico de la aplicación). ¿Hay un solo controlador que atrapa todo?

Véase también esto en StackOverflow .

Estoy usando Visual Studio 2008.

No hay un controlador universal. Necesitas instalar cada uno. He usado algo como esto:

/////////////////////////////////////////////////////////////////////////// template class MapInitializer { std::map m; public: operator std::map() const { return m; } MapInitializer& Add( const K& k, const V& v ) { m[ k ] = v; return *this; } }; /////////////////////////////////////////////////////////////////////////// struct StructuredException : std::exception { const char *const msg; StructuredException( const char* const msg_ ) : msg( msg_ ) {} virtual const char* what() const { return msg; } }; /////////////////////////////////////////////////////////////////////////// class ExceptionHandlerInstaller { public: ExceptionHandlerInstaller() : m_oldTerminateHandler( std::set_terminate( TerminateHandler ) ) , m_oldUnexpectedHandler( std::set_unexpected( UnexpectedHandler ) ) , m_oldSEHandler( _set_se_translator( SEHandler ) ) {} ~ExceptionHandlerInstaller() { std::set_terminate( m_oldTerminateHandler ); std::set_unexpected( m_oldUnexpectedHandler ); _set_se_translator( m_oldSEHandler ); } private: static void TerminateHandler() { TRACE( "\n\n**** terminate handler called! ****\n\n" ); } static void UnexpectedHandler() { TRACE( "\n\n**** unexpected exception handler called! ****\n\n" ); } static void SEHandler( const unsigned code, EXCEPTION_POINTERS* ) { SEMsgMap::const_iterator it = m_seMsgMap.find( code ); throw StructuredException( it != m_seMsgMap.end() ? it->second : "Structured exception translated to C++ exception." ); } const std::terminate_handler m_oldTerminateHandler; const std::unexpected_handler m_oldUnexpectedHandler; const _se_translator_function m_oldSEHandler; typedef std::map SEMsgMap; static const SEMsgMap m_seMsgMap; }; /////////////////////////////////////////////////////////////////////////// // Message map for structured exceptions copied from the MS help file /////////////////////////////////////////////////////////////////////////// const ExceptionHandlerInstaller::SEMsgMap ExceptionHandlerInstaller::m_seMsgMap = MapInitializer() .Add( EXCEPTION_ACCESS_VIOLATION, "The thread attempts to read from or write to a virtual address for which it does not have access. This value is defined as STATUS_ACCESS_VIOLATION." ) .Add( EXCEPTION_ARRAY_BOUNDS_EXCEEDED, "The thread attempts to access an array element that is out of bounds, and the underlying hardware supports bounds checking. This value is defined as STATUS_ARRAY_BOUNDS_EXCEEDED." ) .Add( EXCEPTION_BREAKPOINT, "A breakpoint is encountered. This value is defined as STATUS_BREAKPOINT." ) .Add( EXCEPTION_DATATYPE_MISALIGNMENT, "The thread attempts to read or write data that is misaligned on hardware that does not provide alignment. For example, 16-bit values must be aligned on 2-byte boundaries, 32-bit values on 4-byte boundaries, and so on. This value is defined as STATUS_DATATYPE_MISALIGNMENT." ) .Add( EXCEPTION_FLT_DENORMAL_OPERAND, "One of the operands in a floating point operation is denormal. A denormal value is one that is too small to represent as a standard floating point value. This value is defined as STATUS_FLOAT_DENORMAL_OPERAND." ) .Add( EXCEPTION_FLT_DIVIDE_BY_ZERO, "The thread attempts to divide a floating point value by a floating point divisor of 0 (zero). This value is defined as STATUS_FLOAT_DIVIDE_BY_ZERO." ) .Add( EXCEPTION_FLT_INEXACT_RESULT, "The result of a floating point operation cannot be represented exactly as a decimal fraction. This value is defined as STATUS_FLOAT_INEXACT_RESULT." ) .Add( EXCEPTION_FLT_INVALID_OPERATION, "A floatin point exception that is not included in this list. This value is defined as STATUS_FLOAT_INVALID_OPERATION." ) .Add( EXCEPTION_FLT_OVERFLOW, "The exponent of a floating point operation is greater than the magnitude allowed by the corresponding type. This value is defined as STATUS_FLOAT_OVERFLOW." ) .Add( EXCEPTION_FLT_STACK_CHECK, "The stack has overflowed or underflowed, because of a floating point operation. This value is defined as STATUS_FLOAT_STACK_CHECK." ) .Add( EXCEPTION_FLT_UNDERFLOW, "The exponent of a floating point operation is less than the magnitude allowed by the corresponding type. This value is defined as STATUS_FLOAT_UNDERFLOW." ) .Add( EXCEPTION_GUARD_PAGE, "The thread accessed memory allocated with the PAGE_GUARD modifier. This value is defined as STATUS_GUARD_PAGE_VIOLATION." ) .Add( EXCEPTION_ILLEGAL_INSTRUCTION, "The thread tries to execute an invalid instruction. This value is defined as STATUS_ILLEGAL_INSTRUCTION." ) .Add( EXCEPTION_IN_PAGE_ERROR, "The thread tries to access a page that is not present, and the system is unable to load the page. For example, this exception might occur if a network connection is lost while running a program over a network. This value is defined as STATUS_IN_PAGE_ERROR." ) .Add( EXCEPTION_INT_DIVIDE_BY_ZERO, "The thread attempts to divide an integer value by an integer divisor of 0 (zero). This value is defined as STATUS_INTEGER_DIVIDE_BY_ZERO." ) .Add( EXCEPTION_INT_OVERFLOW, "The result of an integer operation causes a carry out of the most significant bit of the result. This value is defined as STATUS_INTEGER_OVERFLOW." ) .Add( EXCEPTION_INVALID_DISPOSITION, "An exception handler returns an invalid disposition to the exception dispatcher. Programmers using a high-level language such as C should never encounter this exception. This value is defined as STATUS_INVALID_DISPOSITION." ) .Add( EXCEPTION_INVALID_HANDLE, "The thread used a handle to a kernel object that was invalid (probably because it had been closed.) This value is defined as STATUS_INVALID_HANDLE." ) .Add( EXCEPTION_NONCONTINUABLE_EXCEPTION, "The thread attempts to continue execution after a non-continuable exception occurs. This value is defined as STATUS_NONCONTINUABLE_EXCEPTION." ) .Add( EXCEPTION_PRIV_INSTRUCTION, "The thread attempts to execute an instruction with an operation that is not allowed in the current computer mode. This value is defined as STATUS_PRIVILEGED_INSTRUCTION." ) .Add( EXCEPTION_SINGLE_STEP, "A trace trap or other single instruction mechanism signals that one instruction is executed. This value is defined as STATUS_SINGLE_STEP." ) .Add( EXCEPTION_STACK_OVERFLOW, "The thread uses up its stack. This value is defined as STATUS_STACK_OVERFLOW." ); 

Luego en main o app init, hago esto:

 BOOL CMyApp::InitInstance() { ExceptionHandlerInstaller ehi; // ... } 

Tenga en cuenta que esto traduce las excepciones estructuradas a las excepciones regulares, pero maneja la terminación (que se llama, por ejemplo, cuando una función nothrow () lanza una excepción) simplemente imprimiendo un mensaje de error. Es muy poco probable que desee utilizar un solo controlador para todos los diferentes tipos de errores, por lo que no lo proporcionan.

Me gustaría advertir contra esto.

Los errores internos no son recuperables. Si divide por cero o lo que sea, el progtwig no es recuperable.

Si convierte un controlador de terminación en algo que continúa con la ejecución del progtwig, no puede tener garantías del ESTADO del progtwig y puede bloquearse y dañarse de diferentes maneras más adelante. ¡Imagine que el progtwig tenía algunos lockings u otros recursos en el momento de la terminación que desvió, por ejemplo!

Vamos a tener un ejemplo desagradable:

 void log(const char* fmt,...) { lock(logfile); va_args... fvprintf(logfile,fmt,__... <--- this line calls the terminator unlock(logfile); } 

¿Qué pasa si no terminas el progtwig? ¿Qué sucede con el progtwig la próxima vez que alguien intente registrar algo?

No puedo enfatizar esto lo suficiente: debe usar métodos de terminación de enlace para el registro adicional y nada más. Siempre debes seguir saliendo después.


Hay una clase de error completamente diferente, que puede ser interceptada:

Muchas API se comunican con la persona que llama utilizando códigos de retorno para indicar condiciones de error. Es apropiado usar macros o funciones de ayuda para verificar estos códigos de retorno y traducirlos en excepciones. Esto se debe a que esa elección está en tu código donde puedes verla.

Si reemplaza el controlador _set_errno o algo así, provocaría que el código que no había escrito y que esperaba que el configurador regresara normalmente no regrese, y es posible que no haya completado su limpieza.