evincarofautumn on C++11: Try/Catch/Finally Pattern Using RAII & Lambdas

Comment on C++11: Try/Catch/Finally Pattern Using RAII & Lambdas parent

You’re quite right that ignoring the (programmer) error is too lax, but std::terminate() is far too extreme. This is perhaps a situation for std::nested_exception:

    ~finally_type() {
        try {
            function();
        } catch (...) {
            std::throw_with_nested(std::logic_error
                ("Exception thrown from \"finally\"."));
        }
    }

It might pollute calling code a bit with calls to std::rethrow_if_nested(), but I think it’s worth it for the safety.

ot 14y

No, if the finally clause is called while an exception is active, the runtime will call std::terminate(). This is why it is bad practice to throw exceptions in destructors.

Hence, in most cases where the scope guard pattern is used (to guarantee exception safety), your code is basically equivalent to calling std::terminate().

evincarofautumn 14y

Alright, yeah, no exception should escape the finally destructor. After so many years of using it, I should know better than to write C++.

But anyway, the problem is still programmer error. Just as you shouldn’t throw an exception from a destructor, you shouldn’t throw an exception from a “finally”, because it is, by definition, run in a destructor. So, sure, calling std::terminate() explicitly makes about as much sense as anything, but I’d prefer to ignore (and perhaps log) such erroneous exceptions, for reasons of stability.

Comments