Защита выхода из области С++ 11, хорошая идея?

Но хорошая ли это идея?

Конечно. Связанной темой является парадигма RAII.

Или есть потенциальные проблемы, которые я пропустил?

Вы не обрабатываете исключения.

Есть ли уже подобное решение (с функциями С++ 0x) в boost или аналогичном?

Александреску давно придумал ScopeGuard. И в Boost, и в std::tr1 есть вещь под названием scoped_ptr и < href="http://msdn.microsoft.com/en-us/library/bb982026.aspx" rel="noreferrer">shared_ptr (с пользовательским средством удаления), который позволяет вам выполнить именно это.

Для справки: Boost ScopeExit.

Охранники области, безусловно, хорошая идея. Я думаю, что концепция защиты области действия является мощным инструментом для обеспечения безопасности исключений. Если вы можете сделать более безопасную и чистую версию, ScopeExit с использованием синтаксиса C++0x, я думаю, это стоит вашего времени.

Подобно ScopeGuard от Александреску и ScopeExit от Boost, Язык программирования D имеет прямой синтаксис для подобных вещей. Команда разработчиков D решила, что защита области действия была достаточно хорошей идеей, поэтому они добавили ее непосредственно в язык (т.е. он не реализован в библиотеке).

Пример.

void foo( bool fail )
{
   scope(exit)
   {
      writeln("I'm always printed");
   }

   scope(success) writeln("The function exited normally");

   scope(error)
      writeln("The function exited with an exception.");

   if( fail )
      throw new Exception("Die Die Die!");
}

Охранники на основе прицела не являются чем-то новым. Его функциональность может быть легко воспроизведена с помощью деструктора класса (RAII и все такое). Также можно заменить на try/finally в C# или Java. Черт возьми, даже pthreads предоставляет элементарную защиту области видимости, называемую pthread_cleanup_push.

Что делает защиту области действия такой мощной, так это наличие нескольких операторов scope(*) в функции. Он невероятно хорошо масштабируется, в отличие от try/finally, которые требуют сверхчеловеческих способностей, чтобы управлять чем-то большим, чем два.

Если заменить create_scope_exit бинарным оператором, мы можем убрать скобки:

class at_scope_exit
{
    template<typename F>
    struct scope_exit_fn_holder : boost::noncopyable
    {
        scope_exit_fn_holder(F&& f) : f(std::forward<F>(f)) {}

        F f;
        ~scope_exit_fn_holder() { f(); }
    };

    template<typename F>
    friend scope_exit_fn_holder<F> operator==(at_scope_exit, F&& f)
    {
        return scope_exit_fn_holder<F>(std::forward<F>(f));
    }
};

Использование:

auto atScopeExit = at_scope_exit() == [&]
{
    ...
};

upd:
Соответствующий макрос:

#include <boost/preprocessor/cat.hpp>

#define AT_SCOPE_EXIT auto BOOST_PP_CAT(scopeExit_, __LINE__) = at_scope_exit() == [&]
#define AT_SCOPE_EXIT_EX(...) auto BOOST_PP_CAT(scopeExit_, __LINE__) = at_scope_exit() == [__VA_ARGS__]

Для справки: в TS 3 есть scope_exit.

Реализация может быть очень упрощена с использованием tr1::function и tr1::unique_ptr, как показано ниже:

namespace detail
{
    class ScopeGuard
    {
    public:
        explicit ScopeGuard(std::function<void()> onExitScope) 
            : onExitScope_(onExitScope), dismissed_(false)
        { }

        ~ScopeGuard()
        {
            try
            {
                if(!dismissed_)
                {
                    onExitScope_();
                }
            }
            catch(...){}
        }

        void Dismiss()
        {
            dismissed_ = true;
        }
    private:
        std::function<void()> onExitScope_;
        bool dismissed_;

        // noncopyable
    private:
        ScopeGuard(ScopeGuard const&);
        ScopeGuard& operator=(ScopeGuard const&);
    };
}

inline std::unique_ptr<detail::ScopeGuard> CreateScopeGuard(std::function<void()> onExitScope)
{
    return std::unique_ptr<detail::ScopeGuard>(new detail::ScopeGuard(onExitScope));
}

Мы могли бы опустить уродливые [&] вещи, поместив их в определение:

#define UTILITY_SCOPE_EXIT(f) const auto& _UTILITY_EXIT_SCOPE_LINENAME(EXIT, __LINE__) = ::detail::create_scope_exit([&]f)

Потом:

UTILITY_SCOPE_EXIT({myfile.close();});

Протестировано с помощью MSVC++ 11.0 (VS2012). С Уважением.

Это хорошая идея, но есть пара проблем с вашим классом.

1. вы должны отключить новый оператор (вы не хотите, чтобы пользователь использовал его таким образом, что это заставляет вызывать удаление, верно?)
2. вам нужна функция «зафиксировать», чтобы это было защита области вместо простого RAII

обратите внимание, что если вы реализуете пункт 2, вам нужно осмысленное имя для каждого экземпляра области видимости, который вы создаете. Это, в общем-то, не проблема, но может быть в вашем приложении (или на ваш вкус).

Наконец, этот вопрос, вероятно, был бы более подходящим для CodeReview.

Использование Boost:

#include <boost/preprocessor/cat.hpp>

template<class Fn>
class ScopeGuardDetails {
    const Fn m_fn;
public:
    constexpr ScopeGuardDetails(Fn &&fn) : m_fn(fn) {}
    ~ScopeGuardDetails() { m_fn(); }
};
#define ScopeGuardName BOOST_PP_CAT(BOOST_PP_CAT(__scope_guard, _), BOOST_PP_CAT(BOOST_PP_CAT(__LINE__, _), __COUNTER__))
#define defer(stmt) const auto ScopeGuardName = [](const auto _fn) { \
    return ScopeGuardDetails<decltype(_fn)> { std::move(_fn) }; \
}([&] { stmt });

Использование:

if (gdiplus::GdiplusStartup(&token, &startupInput, nullptr) == Gdiplus::Ok) {
    defer({
        gdiplus::GdiplusShutdown(token);
    });
    ...
}