06.02.2013 0:40, Emil Dotchevski:

I'm not an expert on D but Google tells me that it doesn't support automatic deterministic termination.

Could you please describe what do you mean?

So, if you have a file or a handle open, you need scope(exit) to close it. It also means that the programmer must keep track of all non-memory resources and dispose them "manually" like a C programmer.

In C++, RAII makes scope(exit) unnecessary,

While scope(exit) is some kind of ad-hoc replacement for RAII wrappers, scope(failure) and scope(success) are not. Nowadays scope(failure) and scope(success) are emulated in C++ via ScopeGuard idiom. For motivating examples check: ScopeGuard: http://www.drdobbs.com/cpp/generic-change-the-way-you-write-excepti/18440375... scope(failure)/scope(success): http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2012/Three-Unlikely-Succ... , http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Andrei-Alexandre... (ScopeGuard11 part)

and catch(...) is the same as scope(failure).

Compare: scope(failure) { rollback1(); }; do1(); scope(failure) { rollback2(); }; do2(); scope(failure) { rollback3(); }; do3(); with try { do1(); try { do2(); try { do3(); } catch(...) { rollback3(); throw; } } catch(...) { rollback2(); throw; } } catch(...) { rollback1(); throw; } -- Evgeny Panasyuk

06.02.2013 2:57, Emil Dotchevski:

I mean that in D/Java/C#/etc you don't know when the destructor will get called automatically, which means that you're stuck with having to manually keep track of all allocated resources exactly like in C, except for memory.

scope(exit) (in C++) has similar behaviour to normal destructors, and in fact it is implemented on top of destructors. scope(failure) and scope(success) differs from scope(exit) only by additional condition - code in scope(failure) is called only when scope is exited by exception, and code in scope(success) is called only during "normal" scope exit. D's documentation says ( http://dlang.org/statement.html#ScopeGuardStatement ) : "The ScopeGuardStatement executes NonEmptyOrScopeBlockStatement at the close of the current scope, rather than at the point where the ScopeGuardStatement appears." Regarding C# and Java: they have some "workarounds" for resource management: C# has "using", and Java has "try-with-resources". Regarding C: there are also approaches to manage resources automatically, but that's another story.

...

While scope(exit) is some kind of ad-hoc replacement for RAII wrappers, scope(failure) and scope(success) are not. Nowadays scope(failure) and scope(success) are emulated in C++ via ScopeGuard idiom.

Could you clarify what does uncaught_exceptions_count() use look like? How is it different scope guard?

For instance, check first example at Boost.ScopeExit documentation (C++98 syntax): http://www.boost.org/doc/libs/1_53_0/libs/scope_exit/doc/html/index.html void world::add_person(person const& a_person) { bool commit = false; persons_.push_back(a_person); BOOST_SCOPE_EXIT(&commit, &persons_) { if(!commit) persons_.pop_back(); } BOOST_SCOPE_EXIT_END // ... commit = true; } Using SCOPE_FAILURE it would became (C++98 syntax): void world::add_person(person const& a_person) { persons_.push_back(a_person); SCOPE_FAILURE(&persons_) { persons_.pop_back(); } SCOPE_FAILURE_END // ... } Also, there are side-by-side examples at https://github.com/panaseleus/stack_unwinding#d-style-scope-guardsactions . -- Evgeny Panasyuk

06.02.2013 4:32, Emil Dotchevski:

I was asking specifically how uncaught_exception_count would be used.

Here is self-contained example of uncaught_exception_count_latch (which is thin wrapper around uncaught_exception_count): http://ideone.com/jCCew0 -- Evgeny Panasyuk

06.02.2013 16:36, Vicente J. Botet Escriba:

Hi, +1 for both inclusions.

Thank you for interest. 06.02.2013 7:30, Andrey Semashev:

...

I was asking specifically how uncaught_exception_count would be used.

I'm using uncaught_exception_count in a few places of Boost.Log to implement guards that do the main work in destructor and only when an exception is not being thrown. For instance, this expression:

BOOST_LOG(lg) << foo();

will create a guard object that will collect the result of foo into a stream and emit a log record on destructor if foo doesn't throw.

Thank you, that is interesting example - without uncaught_exception_count it would be not easy to achieve same syntax. However, here is my attempt: http://ideone.com/ynQ2XX . And honestly, if that "for"-based approach would cover all your needs - I would prefer it instead of uncaught_exception_count - because it is more portable. Though uncaught_exception_count still has some good use cases. -- Evgeny Panasyuk