Is there a way to determine if an exception is occurring?

Question

In a destructor, is there a way to determine if an exception is currently being processed?

Answer 1

You can use std::uncaught_exception(), but it might not do what you think it does: see GoTW#47 for more information.

Answer 2

You can use again BOOST with library Boost Test Library Look here for an small example :
struct my_exception1
{
explicit my_exception1( int res_code ) : m_res_code( res_code ) {}
int m_res_code;
};

struct my_exception2
{
explicit my_exception2( int res_code ) : m_res_code( res_code ) {}
int m_res_code;
};

class dangerous_call {
public:
dangerous_call( int argc ) : m_argc( argc ) {}
int operator()()
{
if( m_argc < 2 )
throw my_exception1( 23 );
if( m_argc > 3 )
throw my_exception2( 45 );
else if( m_argc > 2 )
throw "too many args";

return 1;
}

private:
int m_argc;
};

void translate_my_exception1( my_exception1 const& ex )
{
std::cout << "Caught my_exception1(" << ex.m_res_code << ")"<< std::endl;
}

void translate_my_exception2( my_exception2 const& ex )
{
std::cout << "Caught my_exception2(" << ex.m_res_code << ")"<< std::endl;
}

int
cpp_main( int argc , char *[] )
{
::boost::execution_monitor ex_mon;
ex_mon.register_exception_translator(&translate_my_exception1);
ex_mon.register_exception_translator(&translate_my_exception2);
try{
// ex_mon.detect_memory_leak( true);
ex_mon.execute( ::boost::unit_test::callback0( dangerous_call(
argc ) ) );
}
catch ( boost::execution_exception const& ex ) {
std::cout << "Caught exception: " << ex.what() << std::endl;
}
return 0;
}

You have to dig in the documentation ...is a very powerful library to testy your software ! Anyway with the help of boost you can catch any kind of exception trigerred anywhere in your function test !

Answer 3

This smells suspicious. Why would you want to a different kind of cleanup if an exception occurred?

Answer 4

As Luc said, you can use std::uncaught_exception(). But why do you want to know? In any case, destructors should never throw exceptions!