Question

I have 3 questions:

1. Can I bind a lvalue directly to a rvalue reference?

2. What happens to the object that being std::move()?

3. What’s the difference between std::move and std::forward?

struct myStr{
    int m_i;
};

void foo(myStr&& rs) { }

myStr rValueGene()
{
    return myStr();
}

int main() 
{
    myStr mS= {1};
    foo(rValueGene()); //ok passing in modifiable rvalue to rvalue reference

    // To Question 1:
    //below initilize rvalue reference with modifiable lvalue, should be ok
    //but VS2010 gives a compile error: error C2440: 'initializing' : cannot convert from    'myStr' to 'myStr &&' 
    //Is this correct ?
    myStr&& rvalueRef = mS;

    //by using std::move it seems ok, is this the standard way of doing this 
    //to pass a lvalue to rvalue reference
    //myStr&& rvalueRef = std::move(mS);

    // To Question 2:    
    //also what happens to mS object after std::move ?
    //destroyed , undefined ?
}

Answer 1

1>Can I bind a lvalue directly to a rvalue reference ?

Not without an explicit cast (ie: std::move).

2>What happens to the object that being std::move() ?

Nothing until it is actually moved. All std::move does is return an r-value reference to what you gave it. The actual moving happens in the move constructor/assignment of the type in question.

3>What’s the difference between std::move and std::forward ?

std::move is for moving; std::forward is for forwarding. That sounds glib, but that’s the idea. If you are intending for an object to be moved, then you use std::move. If you are intending for an object to be forwarded, you use std::forward.

Forwarding uses specialized semantics that allow conversions between types of references, so that the reference natures are preserved between calls. The specifics of all of this are very… technical.

std::move always returns a &&. If you give it an l-value reference, it returns an r-value reference. If you give it a value type, it returns an r-value reference to that value. And so forth.

std::forward does not always return a &&. Syntactically, std::forward is just doing a static_cast<T&&>. However, because of specialized syntax around casting to && types, this cast does not always return a &&. Yes, that’s weird, but it solves the forwarding problem, so nobody cares. That’s why it’s contained in std::forward, rather than having to explicitly do the static_cast yourself.