¿Cómo puedo determinar la excepción actual en un bloque catch (...)?

Question

Duplicar posible:
Determining exception type after the exception is caught?

seguimiento a este question, me gustaría imprimir la excepción actual en un captura (...) bloquear - simplemente para el registro Una respuesta no dice que no hay una forma estándar de hacer esto, pero no me gusta tomar un no por respuesta :-)

current_exception() es una función mencionado en varios lugares en la web pero al parecer no bien apoyado Tiene alguna idea sobre esto? Después de todo, incluso C tiene errno.

Dado que se puede volver a lanzar (con un simple ** tiro *), el objeto de excepción debe estar disponible de alguna manera.

Estoy usando MSVS 9.0.

Editar: La conclusión parece ser que esto no es posible.

Answer 1

Puede activar RTTI y utilizar la función typeOf. current_exception es una función puramente stl, y solo se aplica a las excepciones stl.
Como recomendación, utilice diferentes catch(exctype) por tipo de excepción. Esto hará la vida mucho más fácil.

Answer 2

Como dijo alemjerus: current_exception funciona solo para stl excepciones. Para obtener varios errores STL también se puede escribir:

#include <stdexcept> 
#include <exception> //ecxeption (base class) 
#include <new>  //bad_alloc 
#include <typeinfo> //bad_cast und bad_typeid 
#include <ios>  //ios_base::failure  

... 

try 
{ 
    ... 
} 
catch(std::exception& e) 
{ 
    cerr<<"Error: "<<e.what()<<endl; 
} 

Answer 3

determinar qué excepciones puede ser lanzada y utilizar un conjunto de controladores de captura para capturar un conjunto de tipos de bases comunes que las incluye todas.

---

En cuanto a conseguir el objeto de excepción de la captura (...), no se puede hacer de forma portátil y por lo que yo sé, no se puede hacer nada con el compilador gcc o Microsoft. ¿Qué te hace pensar que el objeto de excepción todavía existe en un controlador catch (...)?

Answer 4

Si solo le importan las excepciones que conoce cuando escribe el código, puede escribir un controlador que pueda manejar todas las excepciones 'conocidas'. El truco consiste en volver a lanzar la excepción de que se pillan con catch(...) y luego coger las diversas excepciones conocidas ...

Por lo tanto, algo así como:

try 
{ 
... 
} 
catch(...) 
{ 
    if (!LogKnownException()) 
    { 
     cerr << "unknown exception" << endl; 
    } 
} 

donde LogKnownException() se ve algo como esto:

bool LogKnownException() 
{ 
    try 
    { 
     throw; 
    } 
    catch (const CMyException1 &e) 
    { 
     cerr << "caught a CMyException: " << e << endl; 

     return true; 
    } 
    catch (const Blah &e) 
    { 
     ... 
    } 
    ... etc 

    return false; 
}