Does throw inside a catch ellipsis (…) rethrow the original error in C++?

by

Yes. The exception is active until it’s caught, where it becomes inactive. But it lives until the scope of the handler ends. From the standard, emphasis mine:

§15.1/4: The memory for the temporary copy of the exception being thrown is allocated in an unspecified way, except as noted in 3.7.4.1. The temporary persists as long as there is a handler being executed for that exception.

That is:

catch(...)
{ // <--

    /* ... */

} // <--

Between those arrows, you can re-throw the exception. Only when the handlers scope ends does the exception cease to exist.

In fact, in §15.1/6 the example given is nearly the same as your code:

try {
    // ...
}
catch (...) { // catch all exceptions
    // respond (partially) to exception <-- ! :D
    throw; //pass the exception to some
           // other handler
}

Keep in mind if you throw without an active exception, terminate will be called. This cannot be the case for you, being in a handler.

If doSomethingElse() throws and the exception has no corresponding handler, because the original exception is considered handled the new exception will replace it. (As if it had just thrown, begins stack unwinding, etc.)

That is:

void doSomethingElse(void)
{
    try
    {
        throw "this is fine";
    }
    catch(...)
    {
        // the previous exception dies, back to
        // using the original exception
    }

    try
    {
        // rethrow the exception that was
        // active when doSomethingElse was called
        throw; 
    }
    catch (...)
    {
        throw; // and let it go again
    }

    throw "this replaces the old exception";
    // this new one takes over, begins stack unwinding
    // leaves the catch's scope, old exception is done living,
    // and now back to normal exception stuff
}

try
{
    throw "original exception";
}
catch (...)
{
  doSomethingElse();
  throw; // this won't actually be reached,
         // the new exception has begun propagating
}

Of course if nothing throws, throw; will be reached and you’ll throw your caught exception as expected.

More Related Contents:

  1. Throwing exceptions from constructors
  2. Should I use an exception specifier in C++?
  3. How do exceptions work (behind the scenes) in c++
  4. Difference between C++03 throw() specifier C++11 noexcept
  5. Exception Handling with pointer [closed]
  6. Possibilities to quit a function
  7. When should I really use noexcept?
  8. Object destruction in C++
  9. How can I propagate exceptions between threads?
  10. How to know the exact line of code where an exception has been caused?
  11. C++ catching all exceptions
  12. When and how should I use exception handling?
  13. Why catch an exception as reference-to-const?
  14. c++ exception : throwing std::string
  15. In what ways do C++ exceptions slow down code when there are no exceptions thown?
  16. Catching exceptions from a constructor’s initializer list
  17. How much footprint does C++ exception handling add
  18. What should I know about Structured Exceptions (SEH) in C++?
  19. How is the C++ exception handling runtime implemented?
  20. boost thread throwing exception “thread_resource_error: resource temporarily unavailable”
  21. Why destructor is not called on exception?
  22. Reset Cuda Context after exception
  23. Determining exception type after the exception is caught?
  24. Deprecated throw-list in C++11
  25. What happens if a constructor throws an exception?
  26. C++ : handle resources if constructors may throw exceptions (Reference to FAQ 17.4]
  27. Under what circumstances are C++ destructors not going to be called?
  28. Measuring exception handling overhead in C++
  29. New (std::nothrow) vs. New within a try/catch block
  30. Why is a segmentation fault not recoverable?

Leave a Comment