C++11 scope exit guard, a good idea?

Question

I've written a small utility class for C++11 which I use as a scope guard for easier handling of exception safety and similar things.

Seems somewhat like a hack. But I'm suprised I haven't seen it somewhere else using C++11 features. I think boost has something similar for C++98.

But is it a good idea? Or are there potential problems I have missed? Is there already a similar solution (with C++11 features) in boost or similar?

    namespace detail      {         template<typename T>         class scope_exit : boost::noncopyable         {         public:                      explicit scope_exit(T&& exitScope) : exitScope_(std::forward<T>(exitScope)){}             ~scope_exit(){try{exitScope_();}catch(...){}}         private:             T exitScope_;         };                    template <typename T>         scope_exit<T> create_scope_exit(T&& exitScope)         {             return scope_exit<T>(std::forward<T>(exitScope));         }     }   #define _UTILITY_EXIT_SCOPE_LINENAME_CAT(name, line) name##line #define _UTILITY_EXIT_SCOPE_LINENAME(name, line) _UTILITY_EXIT_SCOPE_LINENAME_CAT(name, line) #define UTILITY_SCOPE_EXIT(f) const auto& _UTILITY_EXIT_SCOPE_LINENAME(EXIT, __LINE__) = ::detail::create_scope_exit(f) 

and it's used something like.

int main ()  {   ofstream myfile;   myfile.open ("example.txt");   UTILITY_SCOPE_EXIT([&]{myfile.close();}); // Make sure to close file even in case of exception   myfile << "Writing this to a file.\n"; // Imagine this could throw   return 0; } 

Answer 1

But is it a good idea?

Sure. A related topic is the RAII paradigm.

Or are there potential problems I have missed?

You don't handle exceptions.

Is there already a similar solution (with C++0x features) in boost or similar?

Alexandrescu came up with ScopeGuard a long time back. Both Boost and std::tr1 has a thing called scoped_ptr and shared_ptr (with a custom deleter) that allows you to accomplish just this.

Answer 2

For the record, there is Boost ScopeExit.