¿Cómo puedo detectar todos los tipos de excepciones en un bloque catch?

Question

En C++, intento capturar todos los tipos de excepciones en una sola captura (como catch(Exception) en C#). ¿Cómo se hace? Y lo que es más, ¿cómo se pueden ver las excepciones de división por cero?

Answer 1

catch (...) 
{ 
    // Handle exceptions not covered. 
} 

consideraciones importantes:

• Un mejor enfoque es atrapar tipos específicos de excepción de que en realidad se puede recuperar de oposición a todas las excepciones posibles.
• catch (...) también detectará ciertas excepciones serias del sistema (varía según el compilador) de las que no podrá recuperar de manera confiable. Atraparlos de esta manera y luego tragarlos y continuarlos puede causar problemas más serios en su programa.
• Dependiendo de su contexto, puede ser aceptable usar catch (...), siempre que se vuelva a lanzar la excepción. En este caso, registra toda la información de estado local útil y luego vuelve a lanzar la excepción para permitir que se propague. Sin embargo, debe leer en el RAII pattern si elige esta ruta.

Answer 2

Haga que todas sus clases de excepciones personalizadas hereden de std :: exception, entonces simplemente puede capturar std :: exception. Aquí es un código de ejemplo:

class WidgetError 
    : public std::exception 
{ 
public: 
    WidgetError() 
    { } 

    virtual ~WidgetError() throw() 
    { } 

    virtual const char *what() const throw() 
    { 
     return "You got you a widget error!"; 
    } 
}; 

Answer 3

Si no recuerdo mal (que ha pasado un tiempo desde que he mirado en C++), creo que el siguiente debe hacer el truco

try 
{ 
// some code 
} 
catch(...) 
{ 
// catch anything 
} 

y una rápida de Google (http://www.oreillynet.com/pub/a/network/2003/05/05/cpluspocketref.html) parece demostrar que estoy en lo correcto.

Answer 4

En C++, el estándar no define una excepción de división por cero, y las implementaciones tienden a no lanzarlas.

Answer 5

no desea querer estar usando catch (...) (es decir, atrapar con la elipsis) a menos que realmente, definitivamente, más probables lo necesiten.

La razón de esto es que algunos compiladores (Visual C++ 6 por nombrar los más comunes) también convierten errores como fallas de segmentación y otras condiciones realmente malas en excepciones que puede manejar utilizando catch (...). Esto es muy malo, porque ya no ves los accidentes.

Y, técnicamente, sí, también puedes tomar la división por cero (para eso tendrás que usar "StackOverflow"), pero realmente deberías evitar hacer esas divisiones desde el principio.

lugar, haga lo siguiente:

• Si en realidad se sabe qué tipo de excepción (s) esperar, atrapar a los tipos y nada más, y
• Si necesita lanzar excepciones a sí mismo, y Necesita capturar todas las excepciones que arrojará, haga que estas excepciones se deriven de std :: exception (como sugirió Adam Pierce) y capte eso.

Answer 6

Si necesita todas las excepciones, incluidas las del sistema operativo, es realmente lo que necesita, debe echar un vistazo a su compilador y sistema operativo. Por ejemplo, en Windows probablemente tengas la palabra clave "__try" o el interruptor del compilador para hacer que "try/catch" capture excepciones SEH, o ambas.

Answer 7

Puede, por supuesto, usar catch (...) { /* code here */ }, pero realmente depende de lo que quiere hacer. En C++ tienes destructores deterministas (ninguno de esos residuos de finalización), así que si quieres limpiar, lo correcto es usar RAII.

Por ejemplo. en lugar de:

void myfunc() 
{ 
    void* h = get_handle_that_must_be_released(); 
    try { random_func(h); } 
    catch (...) { release_object(h); throw; } 
    release_object(h); 

} 

hacer algo como:

#include<boost/shared_ptr.hpp> 

void my_func() 
{ 
    boost::shared_ptr<void> h(get_handle_that_must_be_released(), release_object); 
    random_func(h.get()); 
} 

crear su propia clase con un destructor si no se utiliza impulso.

Answer 8

Si está en Windows y necesita manejar errores como dividir por cero y violar el acceso, puede usar un traductor de excepción estructurado. Y luego dentro de su traductor puede lanzar una excepción C++:

void myTranslator(unsigned code, EXCEPTION_POINTERS*) 
{ 
    throw std::exception(<appropriate string here>); 
} 

_set_se_translator(myTranslator); 

Nota, el código le dirá lo que fue el error. También necesita compilar con la opción/EHa (C/C++ -> Generatrión de código -> Habilitar excepciones C/C++ = Sí con excepciones SEH).

Si eso no hace que la caja sentido la documentación para [_set_se_translator] (http://msdn.microsoft.com/en-us/library/5z4bw5h5(VS.80).aspx)