std::shared_ptr<void> OnExit(nullptr, [&pList](void*){pList->pop_front();});

BFE>std::shared_ptr<void> OnExit(nullptr, [&pList](void*){pList->pop_front();});
BFE>

auto a = std::move(pList->front());
pList->pop_front();
a.f();

std::unique_ptr<std::list<A>, void(*)(std::list<A>* p)> remover(pList.get(), [](std::list<A>* p){ p->pop_front(); });

A>auto a = std::move(pList->front());
A>pList->pop_front();
A>a.f();
A>

A>std::unique_ptr<std::list<A>, void(*)(std::list<A>* p)> remover(pList.get(), [](std::list<A>* p){ p->pop_front(); });
A>

class at_scope_exit4
{
  public:
    template <class F>
    at_scope_exit4(F&& f): m_f(std::forward<F>(f)){}
   ~at_scope_exit4()
    {
        try{ m_f(); }catch(...){assert(false);}
    }
  private:
    std::function<void()> m_f;
};

auto oOnExit4 = at_scope_exit4([&pList](){pList->pop_front();});

template <class F>
class at_scope_exit5
{
  public:
    at_scope_exit5(F&& f): m_f(std::forward<F>(f)){}
   ~at_scope_exit5()
    {
        try{ m_f(); }catch(...){assert(false);}
    }
  private:
    F m_f;
};

template <class F>
inline
at_scope_exit5<F> make_at_scope_exit5(F&& f)
{
   return std::forward<F>(f);
}

      auto oOnExit5 = make_at_scope_exit5([&pList](){pList->pop_front();});

BFE>      auto oOnExit5 = make_at_scope_exit5([&pList](){pList->pop_front();});
BFE>

{
    auto &&guard = aux * []
    {
        cout << "end of scope" << endl;
    };
    cout << "begin of scope" << endl;
}

#include <iostream>
#include <utility>

template<typename F>
class Guard
{
    F f;
public:
    Guard(const Guard&) = delete;
    Guard(Guard&&) = delete;
    Guard &operator=(const Guard&) = delete;
    Guard &operator=(Guard&&) = delete;

    template<typename T>
    Guard(T &&f)
        : f(std::forward<T>(f))
    {}
    ~Guard() noexcept(noexcept(f()))
    {
        f();
    }
};
 
struct Aux
{
    template<typename F>
    Guard<std::decay_t<F>> operator*(F &&f) const
    {
        return { std::forward<F>(f) };
    }
} constexpr aux{};

using namespace std;

int main()
{
    auto &&guard = aux * []
    {
        cout << "end of scope" << endl;
    };
    cout << "begin of scope" << endl;
}

N>>>>Одни например goto боятся другие макросов...

BFE>>>Я их не боюсь. Я их ненавижу.

http://rsdn.ru/forum/cpp/5116851.1

Автор: B0FEE664
Дата: 29.03.13

BFE>А как надо? (В рамках старого стандарта).

g++ -std=c++11 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
begin of scope
1: guard 2
guard 1

What is std::decay and when it should be used?
It's obviously used to decay radioactive std::atomic types into non-radioactive ones.

template< class T >
using decay_t = typename decay<T>::type;

{
    auto lambda = []
    {
        cout << "end of scope" << endl;
    };
    auto &&guard = make_guard(lambda); // takes reference to lambda

    cout << "begin of scope" << endl;
}

{
    scope_exit
    {
        cout << "end of scope" << endl;
    };
    cout << "begin of scope" << endl;
}