c++ - prueba - trampas ecologicas

cómo atrapar una excepción desconocida e imprimirla

Question

Tengo un programa y cada vez que lo ejecuto arroja una excepción y no sé cómo comprobar exactamente qué arroja, así que mi pregunta es si es posible detectar excepciones e imprimirlas (encontré filas que lanzan excepciones) gracias por adelantado

Answer 1

En C ++ 11 tienes: std::current_exception

Código de ejemplo del sitio:

#include <iostream>
#include <string>
#include <exception>
#include <stdexcept>

void handle_eptr(std::exception_ptr eptr) // passing by value is ok
{
    try {
        if (eptr) {
            std::rethrow_exception(eptr);
        }
    } catch(const std::exception& e) {
        std::cout << "Caught exception /"" << e.what() << "/"/n";
    }
}

int main()
{
    std::exception_ptr eptr;
    try {
        std::string().at(1); // this generates an std::out_of_range
    } catch(...) {
        eptr = std::current_exception(); // capture
    }
    handle_eptr(eptr);
} // destructor for std::out_of_range called here, when the eptr is destructed

Answer 2

Inspirado por la respuesta de Dawid Drozd:

incluir este encabezado #include <exception>

try
{
    // The code that could throw
}
catch(...)
{
    auto expPtr = std::current_exception();

    try
    {
        if(expPtr) std::rethrow_exception(expPtr);
    }
    catch(const std::exception& e) //it would not work if you pass by value
    {
        std::cout << e.what();
    }
}

Answer 3

Pruebe lo sugerido por R Samuel Klatchko primero. Si eso no ayuda, hay algo más que podría ayudar:

a) Coloque un punto de interrupción en el tipo de excepción (manejado o no) si su depurador lo admite.

b) En algunos sistemas, el compilador genera una llamada a una función (¿indocumentada?) cuando se ejecuta una instrucción throw. para averiguar qué función es para su sistema, escriba un programa hello world simple, que arroja y atrapa una excepción. inicie un depurador y coloque un punto de interrupción en el constructor de excepciones, y vea desde donde se está llamando. la función de llamada es probablemente algo así como __throw (). luego, inicie el depurador de nuevo con el programa que desea investigar como depuración. coloque un punto de interrupción en la función mencionada anteriormente (__throw o lo que sea) y ejecute el programa. cuando se lanza la excepción, el depurador se detiene y usted está allí para descubrir por qué.

Answer 4

Si usa ABI para gcc o CLANG, puede conocer el tipo de excepción desconocida. Pero es una solución no estándar.

Ver aquí https://.com/a/24997351/1859469

Answer 5

Si deriva de std::exception , puede capturar por referencia:

try
{
    // code that could cause exception
}
catch (const std::exception &exc)
{
    // catch anything thrown within try block that derives from std::exception
    std::cerr << exc.what();
}

Pero si la excepción es alguna clase que no se deriva de std::exception , deberá saber con anticipación su tipo (es decir, debería capturar std::string o some_library_exception_base ).

Puedes hacer una captura de todo:

try
{
}
catch (...)
{
}

pero luego no puedes hacer nada con la excepción.