Exception behavior C++14 vs C++98

Question

I have written following program

#include <iostream>
#include <stdexcept>

class Myclass
{
    public:
    ~Myclass() 
    {
        //throw std::runtime_error("second (in destructor)");
        throw 1;
    }
};

void fun()
{
    Myclass obj;
}
int main()
{   
    try
    {
        fun();      
    }
    catch (const std::exception& e)
    {
       std::cout << e.what();
    }
    catch(...)
    {
       std::cout << " ... default Catch" << std::endl; 
    }
    std::cout << "Normal" << std::endl;
    return 0;
}  

When I run above program in C++98 mode (cpp.sh) it prints

 ... default Catch
Normal

When I run it with C++14 mode, it does not print anything. Why is there a change in this behavior?

I do understand that whenever any exception occurred and any destructor (within stack unwinding process) throws any exception, it terminates the application. But here only one time exception is thrown from try block that is from destructor.

Answer 1

Since C++11, a destructor without an explicitly spelled out exception specification has the same exception specification as the default-generated one would have. In your case, the default-generated destructor would be noexcept (most default-generated destructors are), so your destructor is considered noexcept as well. Throwing from a noexcept function automatically calls std::terminate.

If you want the exception to be catchable, declare the destructor as throwing:

~Myclass() noexcept(false)
{
    //throw std::runtime_error("second (in destructor)");
    throw 1;
}

But before you do that, reconsider. It's a bad idea to have throwing destructors.

Answer 2

Throwing exceptions from destructors is always a bad idea since if there's already an exception in flight (e.g. destructor called during stack unwinding) std::terminate will be called.

That said, C++11 added an implicit noexcept(true) to destructors (except cases listed below) and that means, again, std::terminate if throwing from a noexcept(true) destructor.

§12.4/3

[class.dtor] [ Note: A declaration of a destructor that does not have a noexcept-specifier has the same exception specification as if had been implicitly declared (15.4). — end note ]

and §15.4/14

[except.spec] The exception specification for an implicitly-declared destructor, or a destructor without a noexcept-specifier, is potentially-throwing if and only if any of the destructors for any of its potentially constructed subojects is potentially throwing.

I strongly recommend restructuring your code in order not to throw in destructors.