CODEWITHSUNDEEP
c++exception
Net Citizen
Net Citizen

Reputation: 5344

Is there any way to get some information at least for catch(...)?

Is there any way to get at least some information inside of here?

...
catch(...)
{
  std::cerr << "Unhandled exception" << std::endl;
}

I have this as a last resort around all my code. Would it be better to let it crash, because then I at least could get a crash report?

Upvotes: 4

Views: 1942

Answers (5)

Richard Hodges
Richard Hodges

Reputation: 69882

here's an approach I used on one project. it involves rethrowing until an exception type is matched against a list of known exceptions and then dispatching some action upon a match (in this case just returning some string information, but it could also be calling a registered function object).

This idea can be extended into a dynamic registry of exception types if you wish, the thing you have to be careful of is to ensure that the list is in most-derived to least-derived order (requires a lot of rethrowing and catching during registration!)

#include <iostream>
#include <stdexcept>
#include <exception>
#include <typeinfo>
#include <system_error>

namespace detail {
    // a function which compares the current exception against a list of exception types terminated
    // with a void type
    // if a match is made, return the exception (mangled) class name and the what() string.
    // note that base classes will be caught if the actual class is not mentioned in the list
    // and the list must be in the order of most-derived to least derived
    //
    template<class E, class...Rest>
    std::string catcher_impl()
    {
        try
        {
            std::rethrow_exception(std::current_exception());
        }
        catch(const E& e)
        {
            bool is_exact = typeid(E) == typeid(e);
            return std::string(typeid(E).name()) + (is_exact ? "(exact)" : "(base class)") + " : " + e.what();
        }
        catch(...)
        {
            return catcher_impl<Rest...>();
        }
        return "unknown";
    }

    // specialise for end of list condition
    template<> std::string catcher_impl<void>()
    {
        return "unknown exception";
    }
}

// catcher interface
template<class...Es>
std::string catcher()
{
    return detail::catcher_impl<Es..., void>();
}

// throw some exception type
// and then attempt to identify it using the type list available
//
template<class E>
void test(E&& ex)
{
    try
    {
        throw std::forward<E>(ex);
    }
    catch(...)
    {
        std::cout << "exception is: "
        << catcher<std::invalid_argument, std::system_error, std::runtime_error, std::logic_error>()
        << std::endl;
    }
}

int main()
{
    test(std::runtime_error("hello world"));
    test(std::logic_error("my logic error"));
    test(std::system_error(std::make_error_code(std::errc::filename_too_long)));
    test(std::invalid_argument("i don't like arguments"));

    struct my_runtime_error : std::runtime_error
    {
        using std::runtime_error::runtime_error;
    };
    test(my_runtime_error("an unlisted error"));
}

example output:

exception is: St13runtime_error(exact) : hello world
exception is: St11logic_error(exact) : my logic error
exception is: NSt3__112system_errorE(exact) : File name too long
exception is: St16invalid_argument(exact) : i don't like arguments
exception is: St13runtime_error(base class) : an unlisted error

Upvotes: 0

John Zwinck
John Zwinck

Reputation: 249153

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.

Upvotes: 4

anon
anon

Reputation:

Yes there is, but how useful it is is open to debate:

#include <exception>
#include <iostream>
using namespace std;

int f() {
    throw "message";
}

int main() {
    try {
        f();
    }
    catch ( ... ) {
        try {
            throw;
        }
        catch( const char *  s ) {
            cout << "caught " << s << endl;
        }
    }
}

And to actually to answer your question, IMHO you should always have a catch(...) at the top level of your code, that terminates (or otherwise handles) when presented with an unexpected exception in your application, in a manner fully documented by your application's manual.

Upvotes: 1

Assaf Lavie
Assaf Lavie

Reputation: 75983

I believe you should catch (...), if you have a reasonable course of action at that point and want the application to keep running.

You don't have to crash in order to generate a crash report, mind you. There's API for generating a mini-dump and you can do it in your SEH handler.

Upvotes: 0

Johannes Schaub - litb
Johannes Schaub - litb

Reputation: 506985

No, there isn't any way. Try making all your exception classes derive from one single class, like std::exception, and then catch that one.

You could rethrow in a nested try, though, in an attempt to figure out the type. But then you could aswell use a previous catch clause (and ... only as fall-back).

Upvotes: 10

Related Questions