C++0x rvalue references and temporaries

Question

(I asked a variation of this question on comp.std.c++ but didn\'t get an answer.)

Why does the call to f(arg) in this code call the const ref overload of

Answer 1

It was a defect in the standard draft you read. This defect got in as a side effect of some eager editing to disallow binding of rvalue references to lvalues for safety reasons.

Your intuition is right. Of course, there is no harm in allowing an rvalue reference to refer to some unnamed temporary even if the initializer was an lvalue expression. After all, this is what rvalue references are for. The issue you observed has been fixed last year. The upcoming standard will mandate that the second overload will be picked in your example where the rvalue reference will refer to some temporary string object.

The rule fix made it into the draft n3225.pdf (2010-11-27):

• [...]
• Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i.e., cv1 shall be const), or the reference shall be an rvalue reference and the initializer expression shall be an rvalue or have a function type. [...]
  • [...]
  • Otherwise, a temporary of [...] is created [...]

        double&& rrd3 = i; // rrd3 refers to temporary with value 2.0

But N3225 seems to have missed to say what i is in this example. The latest draft N3290 contains these examples:

        double d2 = 1.0;
        double&& rrd2 = d2; // error: copying lvalue of related type
        int i3 = 2;
        double&& rrd3 = i3; // rrd3 refers to temporary with value 2.0

Since your MSVC version was released before this issue got fixed, it still handles rvalue references according to the old rules. The next MSVC version is expected to implement the new rvalue reference rules (dubbed "rvalue references 2.1" by MSVC developers) see link.