post-increment without temporary object based on lazy pre-increment

Trying to avoid a temporary copy of *this in post-increment.
But is this code below valid?
rgds,
Frank
==============================================
#include <iostream>

#include <boost/proto/proto.hpp>
using namespace boost;

template <typename Expr>
class Lazy
{
private:
    Expr const & _expr;

public:
    Lazy(Expr const & expr)
    : _expr(expr)
    { }

    ~Lazy()
    {
        proto::eval(_expr, proto::default_context());
    }

private:
    Lazy(const Lazy &);

};

class UPInt; // forward declaration

template <class SUBJECT>
void DoIncrement(SUBJECT * ptr)
{
    std::cout << "DoIncrement()" << std::endl;
    ++(*ptr);
}

class UPInt
{
private:
    int _x;
public:
    UPInt(
        int x)
    : _x(x)
    {}

    UPInt & operator++()
    {
        std::cout << "pre-increment" << std::endl;
        _x+=1;
        return *this;
    }

    const UPInt operator++(int)
    {
        typedef proto::result_of::make_expr<
            proto::tag::function,
            void(*)(UPInt*),
            UPInt *
        
Lazy<f_type> lazy(proto::make_expr<
            proto::tag::function>(
                &DoIncrement<UPInt>,
                this)
            );

        std::cout << "post-increment before exit" << std::endl;
        return *this;
    }

    int operator()(void) const
    {
        return _x;
    }
};

std::ostream & operator<<(
    std::ostream & lhs,
    const UPInt & rhs)
{
    lhs << rhs();
    return lhs;
}

int main(int, char**)
{
    UPInt x(1);
    std::cout << "x = " << x << std::endl;

    ++x;
    std::cout << "x = " << x << std::endl;

    UPInt y(x++);
    std::cout << "y = " << y << std::endl;
    std::cout << "x = " << x << std::endl;

    return 0;
}

========== OUTPUT ========================
x = 1
pre-increment
x = 2
post-increment before exit
DoIncrement()
pre-increment
y = 2
x = 3

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]