Boost logo

Boost :

From: David Abrahams (dave_at_[hidden])
Date: 2004-04-16 08:27:02

"Andrea Torsello" <torsello_at_[hidden]> writes:

> Hi, I have been investigating move semantics and think that I came up with a
> solution that is strongly influenced by both David Abrahams' move approach
> and Andrei Alexandrescu's mojo, but solves some of the problems I have
> encountered with them.
> The basic idea is to use the explicit keyword to force the compiler to use
> the X(X const &) constructor only in two cases.
> 1) When explicitly copying a const object i.e.
> X const x;
> X y(x); //use explicit copy constructor

Not when passing a non-const lvalue?

    X x;
    X y(x); // implicitly uses a move ctor?? That's highly undesirable!

> 2) When passing by const ref
> void f(X const &);
> X makeX();
> void foo()
> {
> f(makeX()); //use explicit copy constructor
> }
> In all other cases the other constructor take precedence.

Which "other constructor"?

> Note that the template trick David Abrahams uses in his move
> approach would lead to an error on a conforming compiler when
> confronted with case #2 (unless more recent versions corrected
> this).

I'm not sure what you mean, but AFAICT case #2 is handled just fine by
conforming compilers. Did you read
It's a question of interpretation of a particular clause of the

> I chose to keep the temporary and constant subtypes from mojo because they
> allow me to discriminate between const values, non-const rvalues and
> non-const rvalues.

const and non-const rvalues are pretty much interchangeable, since the
compiler can turn the former into the latter. If they weren't
interchangeable, I don't see any reason you'd want to treat a const
rvalue differently from a const lvalue.

> The lack of this capability was the major problem I had with David
> Abrahams' move.


> My use-case was a vector-like container that increases but never
> decreases the size of its backing store. In order to provide the
> never decreasing backing-store semantic, operator = moves the
> backing store from a temporary only if the new data does not fit in
> the existing space. Hence, operator = must be able to discriminate
> between temporaries and non-temporaries.

My solution allows discrimination between temporaries and

> My solution fullfills almost all the requirements I had:
> 1) passing by value moves non-const rvalues and copies everithing else.
> 2) its is transparent to the user of the class.
> Alexandrescu's Mojo fails this because of the special return type, while
> Abrahams' move fails it because of the pass-by-const-ref problem described
> above.

Please describe the problem in more detail.

> 3) it allows to discriminate between constants, non-const lvalues, and
> non-const rvalues.
> Alexandrescu's Mojo allows it, while Abrahams' move does not.

Why is that an advantage?

Dave Abrahams
Boost Consulting

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