将左值绑定到右值引用时，std :: forward vs std :: move

Question

is there a difference between move and forward here:

void test(int && val)
{
    val=4;
}

void main()
{  
    int nb;
    test(std::forward<int>(nb));
    test(std::move(nb));
    std::cin.ignore();    
}

Answer 1

In your specific case, no, there isn't any difference.

Detailed answer:

Under the hood, std::move(t) does static_cast<typename std::remove_reference<T>::type&&>(t) , where T is type of t (see §20.2.3/6). In your case, it resolves to static_cast<int&&>(nb) .

forward is a little bit tricky, because it is tailored for use in templates (to allow perfect forwarding) and not as a tool to cast lvalue to rvalue reference.

Standard library provides two overloads (one for lvalue references and the second for rvalue ones, see §20.2.3/2):

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;

Substituting int , we get:

int&& forward(int& t) noexcept;
int&& forward(int&& t) noexcept;

And since nb is lvalue, the first version is chosen. According to standard draft, the only effect of forward is static_cast<T&&>(t) . With T being int , we get static_cast<int&&>(nb) , ie - we get two exactly same casts.

Now, if you want to cast lvalue to rvalue (to allow moving), please use only std::move , which is the idiomatic way to do this conversion. std::forward is not intended to be used this way.

Answer 2

没有不同。

---