Question

As a follow-up to my previous question:

If I change the code as follows:

struct ExceptionBase : virtual std::exception{};
struct SomeSpecificError : virtual ExceptionBase{};
struct SomeOtherError : virtual ExceptionBase{};

void MightThrow();
void HandleException();
void ReportError();

int main()
{
  try
  {
    MightThrow();
  }
  catch( ... )
  {
    HandleException();
  }
}

void MightThrow()
{
  throw SomeSpecificError();
}

void HandleException()
{
  try
  {
    throw;
  }
  catch( ExceptionBase const & )
  {
    // common error processing
  }

  try
  {
    throw;
  }
  catch( SomeSpecificError const & )
  {
    // specific error processing
  }
  catch( SomeOtherError const & )
  {
    // other error processing
  }

  try
  {
    ReportError();
  }
  catch( ... )
  {
  }
}

void ReportError()
{
  throw SomeOtherError();
}

The “last handler” for the original exception (i.e. the one in main) has not exited when the second exception is thrown, so are both exceptions active? Is the original exception still available once we leave the handler for the second exception?

Answer 1

C++11 (N3242):

15.1p4: The memory for the exception object is allocated in an unspecified way, except as noted in 3.7.4.1. If a
handler exits by rethrowing, control is passed to another handler for the same exception. The exception
object is destroyed after either the last remaining active handler for the exception exits by any means other
than rethrowing, or the last object of type std::exception_ptr (18.8.5) that refers to the exception object is
destroyed, whichever is later.

(std::exception_ptr is a C++11 feature, and isn’t used in your example code.)

15.3p7: A handler is considered active when initialization is complete for the formal parameter (if any) of the catch clause. … A handler
is no longer considered active when the catch clause exits or when std::unexpected() exits after being
entered due to a throw.

15.3p8: The exception with the most recently activated handler that is still active is called the currently handled exception.

15.1p8: A throw-expression with no operand rethrows the currently handled exception (15.3).

Or equivalently, I think, throw; always refers to the exception caught by the innermost catch block which is currently executing. Except that I haven’t defined ‘innermost’ and ‘executing’ as carefully as the Standard defined all its terms above.

And yes, more than one exception object can be allocated at a time, and C++ is required to make sure they live long enough to do “the right thing” when you try to rethrow.