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 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
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
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 http://www.boost-consulting.com
Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk