Re:C++11: Try/Catch/Finally Pattern Using RAII & Lambdas
by evincarofautumn on Monday March 12, 2012 @01:20PM
(#3694425)
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.
Re:C++11: Try/Catch/Finally Pattern Using RAII & Lambdas
by ot on Monday March 12, 2012 @01:51PM
(#3694548)
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().
Re:C++11: Try/Catch/Finally Pattern Using RAII & Lambdas
by evincarofautumn on Monday March 12, 2012 @02:04PM
(#3694594)
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.
Re:C++11: Try/Catch/Finally Pattern Using RAII & Lambdas
by code-dog on Monday March 12, 2012 @11:06AM
(#3693759)
Which kinda goes to my point about out of memory exceptions - they generally end up being fatal sooner or later. Trying to catch them just results in memory running out somewhere else. The only place you can deal with them is if the code is doing something you expect to cause memory issues because it is consuming an atypically large amount of memory (like a cache or some such) which you can get away with shrinking.
This would make the error pass silently, possibly leaving the program in an inconsistent state. It is probably better to call std::terminate() instead, which is what C++ does when an exception is thrown when another exception is active.