while(!theList.empty())
{
  A& obj = theList.front();
  try { obj.f(); }
  catch(std::exception const& e) { report_error(e); }
  catch(...) { assertion_fault("неизвестное исключение! мы все умрём!"); throw; } // нет смысла дальше молотить наш цикл
  theList.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;
}

{
    cout << "success case:" << endl;
    scope(exit)
    {
         cout << "exit" << endl;
    };
    scope(success)
    {
        cout << "success" << endl;
    };
    scope(failure)
    {
        cout << "failure" << endl;
    };
}
cout << string(16,'_') << endl;
try
{
    cout << "failure case:" << endl;
    scope(exit)
    {
        cout << "exit" << endl;
    };
    scope(success)
    {
        cout << "success" << endl;
    };
    scope(failure)
    {
        cout << "failure" << endl;
    };
    throw 1;
}
catch(int){}
// OUTPUT:
success case:
success
exit
________________
failure case:
failure
exit

BFE>      A& rA = pList->front();
BFE>      //boost::shared_ptr< std::list<A> > OnExit(pList.get(), boost::mem_fn(&std::list<A>::pop_front)); // variant 1
BFE>      boost::shared_ptr<void> OnExit(pNull, boost::bind(&std::list<A>::pop_front, pList));              // variant 2
      
BFE>      rA.f();
BFE>

{
    A a;
    swap(a, pList->front());
    // или
    // auto a = std::move(pList->front());

    pList->pop_front();

    a.f();
}

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

class A
{
  int m_n;
public:
  A(int n) : m_n(n) {}

  void f()
  { 
    if ( 0 == m_n )
      throw std::runtime_error("zero here");
    
    std::cout << m_n << std::endl;
  }
};


int main()
{
  boost::shared_ptr< std::list<A> > pList(new std::list<A>);

  pList->push_back(A(1));
  pList->push_back(A(2));
  pList->push_back(A(3));
  pList->push_back(A(4));
  pList->push_back(A(0));
  pList->push_back(A(5));

  void* pNull = NULL;

  while(pList->size())
  {
    try
    {
      A& rA = pList->front();
      //boost::shared_ptr< std::list<A> > OnExit(pList.get(), boost::mem_fn(&std::list<A>::pop_front)); // variant 1
      boost::shared_ptr<void> OnExit(pNull, boost::bind(&std::list<A>::pop_front, pList));              // variant 2
      
      rA.f();
    }
    catch(std::exception& e)
    {
      std::cout << "Error: " << e.what() << std::endl;
    }
  }

  std::cout << "Press any key to exit..." << std::endl;
  char ch = getch();
  
  return 0;
}

BFE>  while(!pList->empty())
BFE>  {
BFE>    try
BFE>    {
BFE>      pList->front().f();
BFE>    }
BFE>    catch(std::exception& e)
BFE>    {
BFE>      std::cout << "Error: " << e.what() << std::endl;
BFE>    }
        pList->pop_front();
BFE>  }

boost::shared_ptr<void> OnExit(pNull, boost::bind(&std::list<A>::pop_front, pList));

BFE>>>Вы ещё про заказ памяти посредством new внутри shared_count забыли

boost::shared_ptr<void> OnExit(pNull, boost::bind(&std::list<A>::pop_front, pList));

#include <boost/shared_ptr.hpp>
#include <iostream>
#include <ostream>

using namespace std;

struct Deleter
{
    char stuff[1024];
    void operator()(void*){}
};

int main()
{
    boost::shared_ptr<void> p(0,Deleter());
    cout << "sizeof(p)=" << sizeof(p) << endl;
    cout << "sizeof(Deleter)=" << sizeof(Deleter) << endl;
}

stdout:
sizeof(p)=16
sizeof(Deleter)=1024

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();});

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.

{
    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;
}

EP>Это был такой тонкий намёк на то что на дворе уже C++14

struct Aux2
{
    const Aux2& operator--(int) const
    {
        return *this;
    }

    template<typename F>
    Guard<typename std::decay<F>::type> operator>(F &&f) const
    {
        return { std::forward<F>(f) };
    }
};

const Aux2 make_at_scope_exit{};

        const auto&& guard = make_at_scope_exit7-->[&] { std::cout << "x=" << x << ": guard\n"; };

BFE>

EP>>Это был такой тонкий намёк на то что на дворе уже C++14

auto fibs = fix(cons(0) * cons(1) * (zipWith(sum) <ap> tail));
auto x = fibs <at> 101;

BFE>>

a -------> m_n = 0;

EP>Подразумевалось что мультипликация будет спрятана в макросе

BFE>>>

EP>>Подразумевалось что мультипликация будет спрятана в макросе

scope_exit
{
    // ...
};