Boost logo

Boost :

From: Powell, Gary (powellg_at_[hidden])
Date: 2004-02-11 16:42:02

Nice. I think we'd implement a "move" function which could handle
that explicitly in any real implementation:

    Y(ref rhs)
      : X( move(*rhs.p) ) // <== here
      , id(++cnt)
      , owner(rhs.p->owner)
        std::cout << "MOVE #" << id << " <== #" << rhs.p->id << std::endl;
        rhs.p->owner = false;
Gary > Thank you!

I must be dense but I'm not seeing how a move function would give us
the right type.

template<class T>
??? move(T &)
{... }

    X( move (*rhs.p) ) // T is a Y
                         // calls X copy if move returns T *.

and we need

    X ( X::ref) // and X::ref only takes a X * and X::ref private to X.

What am I missing here?

> All in all
> I like it better than the MOJO soln which IMO was much more
> invasive.

What about the MOJO approach seems more invasive to you?
Gary > Well you need to modify both the functions you use and the class.
And the class requires more modification.

class Y : public ::mojo::enabled<Y>
    Y &operator=(Y const & rhs) // source is a non const lvalue
        using ::std::swap;

        Y tmp(rhs);
        return *this;

    Y &operator=(::mojo::temporary<Y> src) // source is a temporary

        return *this;

    Y &operator=(::mojo::fnresult<Y> src) // source is a fn result
        return operator=(::mojo::temporary<Y>(src));

// Special return type from an object to use it....
// test with binary operator +
::mojo::fnresult<Y> operator +(Y lhs, Y const &rhs) {
    return lhs; // do the addition here

vs with move.cpp, no special type necessary....
Y operator + (Y lhs, Y const &rhs){
   return lhs; // do the addition here.

I have source code that does a similar set of tests with mojo.h as I did for move.cpp if you want to look at it.



Boost list run by bdawes at, gregod at, cpdaniel at, john at