What happens when an exception is thrown while unwinding the stack from another exception?

Question

For example in the following code:

#include <iostream>
using namespace std;
class A {
     public:
           A() { cout << "A::A()" << endl; }
           ~A() { cout << "A::~A()" << endl; throw "A::exception"; }
     };
class B {
     public:
           B() { cout << "B::B()" << endl; throw "B::exception"; }
           ~B() { cout << "B::~B()"; }
     };
int main(int, char**)
{
     try {
           cout << "Entering try...catch block" << endl;
           A objectA;
           B objectB;
           cout << "Exiting try...catch block" << endl;
     }
     catch (char* ex) {
           cout << ex << endl;
     }
     return 0;
}

B's destructor throws an exception, which invokes A's destructor while unwinding the stack, resulting in the throw of another exception. What will be the program's reaction?

Answer 1

Short answer? Bang, application termination.

From parashift:

During stack unwinding, all the local objects in all those stack frames are destructed. If one of those destructors throws an exception (say it throws a Bar object), the C++ runtime system is in a no-win situation: should it ignore the Bar and end up in the

} catch (Foo e) { 

where it was originally headed? Should it ignore the Foo and look for a

} catch (Bar e) { 

handler? There is no good answer — either choice loses information.

So the C++ language guarantees that it will call terminate() at this point, and terminate() kills the process. Bang you're dead.

Related questions on Stack Overflow:

• Why exactly is calling the destructor for the second time undefined behavior in C++?
• throwing exceptions out of a destructor