Get some information from exception caught with catch(…)? [duplicate]

Answer 1

One possibility too, on Windows at least, is to write a minidump using MiniDumpWriteDump to get the exception plus stack traces, memory and lots of useful debugging info.

Answer 2

You can use a debugger and enable break on throw, assuming your exceptions really are exceptional this is a good way to know where its coming from.

Also a word of warning should you ever use catch(...) on windows. Under certain build options this will catch SEH exceptions, these are the kinds of things you should never attempt handle such as reading or writing memory out of bounds.

Answer 3

You can do this using gdb or another debugger. Tell the debugger to stop when any exception is throw (in gdb the command is hilariously catch throw). Then you will see not only the type of the exception, but where exactly it is coming from.

Another idea is to comment out the catch (...) and let your runtime terminate your application and hopefully tell you more about the exception.

Once you figure out what the exception is, you should try to replace or augment it with something that does derive from std::exception. Having to catch (...) at all is not great.

If you use GCC or Clang you can also try __cxa_current_exception_type()->name() to get the name of the current exception type.

Answer 4

As a variant on John Zwinck's suggestion to comment out the catch(...) block to let the run-time terminate the application and hopefully provide some more info, you could

catch (...) 
{
  log("Unknown exception caught in [sensible info here]; will rethrow it");
  throw;
}

then you will at least know where in your program the error occured (if there are several possibilities).

Answer 5

The only way in code (i.e. not using a debugger) to get information from an exception in a catch(...) block is to rethrow the exception, and catch it with specific clauses.

For example.

try
{
    // code that might throw something
}
catch (...)
{
    try_to_interpret_exception();
}

void try_to_interpret_exception()   // we assume an exception is active
{
    try
    {
         throw;    // rethrow the exception.  Calls terminate() if no exception active
    }
    catch (std::exception &)
    {
         // handle all exception types derived from std::exception
         //    this covers all exceptions that might be thrown by
         //    the standard C++ library
    }
    catch (specific_exception &e1)
    {
        //  handle all exception types derived from specific_exception
    }
    catch (another_specific_exception &e2)
    {
         // etc
    }
}

The catch (so to speak) of this approach is that it requires the programmer to have some knowledge of what the exception might be (e.g. from documentation of a third party library). |