why rvalue reference can be bind to a non reference type

Question

int main()
{
    int rx = 0;
    int ry = std::move(rx); //here is the point of my question

    int lx = 0;
    int ly = &lx; //(2) obviously doesn't compile

    std::cin.ignore();
}

I'm a little bit lost with this aspect of rvalue, I can't understand how we can't bind &&rx to ry, because std::move(rx) is a reference to a rvalue, so I believed that this kind of expression could only be bind to a reference type as is it he case for lvalue reference and illustrated in (2)

Not "bind", "copy". You are also confusing references and pointers (`&lx` is a pointer). — Marc Glisse, Dec 29 '13 at 11:18
It's move construction. Just like `A a = some_a` calling the copy constructor, it calls the move constructor. — Xin, Dec 29 '13 at 15:09
I have auto voted to close it, I don"t like my question much longer — Guillaume Paris, Dec 29 '13 at 15:21

score 3 · Accepted Answer · answered Dec 29 '13 at 11:24

3

References != address-of operator.

int& ly = lx; // reference
int* ly = &lx; // pointer

answered Dec 29 '13 at 11:24

Danvil · Answer 2 · 2013-12-29T11:26:56.487

std::move obtains an rvalue reference to its argument and converts it to an xvalue. [1]

Which in turn can be copied to ry.

The expression int ry = std::move(rx); does not "bind" rx to ry. It tells the compiler that rx is no longer needed and that its contents can be moved to ry while at the same time invalidating rx.

This is especially useful when functions return by value:

std::vector<int> foo() {
    std::vector<int> v = {1,2,3,4};
    return v;
}
std::vector<int> u = foo();

At return v the compiler notice that v is no longer needed an that it can actually use it directly as u without doing a deep copy of the vector contents.

why rvalue reference can be bind to a non reference type

2 Answers2