Re: Verbosity when optimizing with rvalue references
On 25 Jun., 15:18, Paul Bibbings wrote:
I've had another look at this and wonder if the following example might
offer something useful.
Well, you posted something that has basically been called "perfect
forwarding" before in this thread. But you included a type (A) that
offers an implicit conversion from int which is an interesting test
case as far as I'm concerned ...
[snip]
class A
{
public:
A(int i) { std::cout << "A::A(int)\n"; } /=
/ ctor
A(const A&) { std::cout << "A::A(const A&)\n"; } // copy c=
tor
A(A&&) { std::cout << "A::A(A&&)\n"; } =
// move ctor
};
[snip]
int main()
{
std::cout << "0: Initialize lvalues (A)...\n";
A a1(1), a2(2);
const A a3(3);
[snip]
std::cout << "\n5: Construct D with (rvalue, rvalue)!...\n";
D d5(1, 2);
std::cout << "\n6: Construct D with (rvalue, lvalue)...\n";
int i2 = 2;
D d6(1, i2);
[snip]
========================
==========+===============
==============
template ctor | overloaded ctor
[snip]
=======================
===========+==============
===============
5: Construct D with (rvalue, rvalue)!...
---------------------------------+----------------------------
A::A(int) | A::A(in=
t)
A::A(int) | A::A(in=
t)
|=
A::A(A&&)
|=
A::A(A&&)
D::D<int, int>(int&&, int&&) | D::D(A&&, A&&)
=======================
===========+==============
===============
6: Construct D with (rvalue, lvalue)...
---------------------------------+----------------------------
A::A(int) | A::A(in=
t)
A::A(int) | A::A(in=
t)
|=
A::A(A&&)
|=
A::A(A&&)
D::D<int, int&>(int&&, int&) | D::D(A&&, A&&)
Even though in test case 6 the 2nd parameter is an lvalue of type int
the overload D::D(A&&,A&&) is selected. So, GCC 4.5 creates a
temporary A object from the int lvalue and binds it to a reference of
type A&&. This is the behavior you might expect. I certainly did.
Unfortunately, the current draft actually forbids this, too. I already
started a comp.std.c++ thread on this:
http://groups.google.com/group/comp.std.c++/browse_thread/thread/2b72ea155e=
039ac6
According to the current draft:
int x = 3;
A&& foo = x; // ill-formed!
A&& foo = A(x); // OK
Even though the conversion from int to A is implicit, the initializer
is still an lvalue expression and no rule in =A78.5.3 of the current
draft allows an rvalue reference to be initialized with an lvalue
expression. So, a compiler conforming to the current draft should have
selected the overload
D::D(A&&, const A&);
in the test case 6. I really hope this will be changed. IMHO it makes
little sense to forbit the temporary to bind to the reference of type
A&& just because the argument was an lvalue expression. So, the const
lvalue reference is initialized with a temporary which kind of works
against the original intent of rvalue references.
As I read this it appears that the parameterized constructor version is
*as* efficient in this sense as the overloaded-constructor version.
The perfect forwarding approach is even better under the current rules
in terms of efficiency (judging by the kind and number of constructors
that are called).
[snip]
The main difference, however, is that non-const lvalues are passed into
the constructor by non-const lvalue refs for the parameterized
constructor version (see 1., 2. & 3, above).
Right. In the general perfect-forwarding case this is not an issue.
And here, it isn't an issue either because we know that string doesn't
behave like auto_ptr. :)
And, there is a further
significant difference. If you modify A's constructor so that it is
explicit then the code fails for the overloaded-constructor version when
invoked with lvalue or rvalue integers. However, for the parameterized
constructor version, it *succeeds*, instantiating the constructor with a
combination of int/int& template arguments (see 6. & 7., above). This
may, or may not, be a boon or a bane, depending upon what is required by
the model as a whole.
You can constrain the template like I did to only accept types that
are implicitly convertible to A. This has other advantages, too.
Cheers!
SG