class foo
{
  private:
    class deferred_increment
    {
      public:
        typedef  foo master_type;

        explicit
        deferred_increment(master_type& m): m_(m) {}
        
        ~deferred_increment() { ++m_; }

      private:
        master_type& m_;
    };
    
    
  public:
    //prefix ++
    foo& operator++()
    {
      /* ... do increment ... */
      return *this;
    }
    
    //postfix ++
    const foo operator++(int)
    {
      deferred_increment inc(*this);
      return *this;                 
              // увеличили  *this  в деструкторе
              // ни одной временной переменной не надо
    }
};

  template <typename _Tp, typename _Sequence>
    class stack
  {
      /* ... pop(), top(), typedefs, ... */

  private:
    class deferred_pop
    {
      public:
        typedef stack<value_type, container_type> master_type;

        explicit deferred_pop(master_type& m): m_(m) {}
        
        ~deferred_pop()
        {
          if (!std::uncaught_exception())
            m_.pop();
        }

      private:
        master_type& m_;
    };
    
  public:
    value_type vpop()
    {
      deferred_pop p(*this) 
      return top();    
      // вызов деструктора p
    }
    /*...*/
  };

НМВ>class foo
НМВ>{
<...поскипано...>
НМВ>    //postfix ++
НМВ>    const foo operator++(int)
НМВ>    {
НМВ>      deferred_increment inc(*this);
НМВ>      return *this;                 
НМВ>              // увеличили  *this  в деструкторе
НМВ>              // ни одной временной переменной не надо
НМВ>    }
НМВ>};
НМВ>

foo operator++(int)
  {
    foo result( *this );
    ++this;
    return result;
  }

var = my_stack.vpop();

var = my_stack.vpop() + my_stack.vpop();

НМВ>аналоги, но поиск на RSDN не работает

    template <class T>
    struct PPhelper
    { T& t;
      PPhelper(T&t_):t(t_){}
      operator T& (){return t;}
      ~PPhelper(){++t;}
    };
    
struct S
{ int v;
  S(int v_=0):v(v_){};
  S& operator++()
    { v++;/* ... do increment ... */
      return *this;
    }

    PPhelper<S> operator++(int){return PPhelper<S>(*this);}
};

int main(int argc, const char *argv[])
{  S a,b(10);
   a=  b++;
   return 0;
}

X foo()
{  X x;
   return x; 
}

X foo()
{  Other other;
   return other; 
}

X foo()
{  Other other;
   X x(other);
   return x; 
}

If many temporaries are created by the evaluation of the initializer, the temporaries are destroyed in reverse order of the completion of their construction.