Question

我一直在观看来自C ++和2012年以后会议的Scott Meyers'talk on Universal References，到目前为止一切都很有意义。然而，一位观众在大约50分钟后问了一个问题，我也在想。迈尔斯说，他不关心答案，因为它不是惯用的，会愚蠢的想法，但我仍然感兴趣。

提供的代码如下：

// Typical function bodies with overloading:
void doWork(const Widget& param)   // copy
{
  // ops and exprs using param
}
void doWork(Widget&& param)        // move
{
  // ops and exprs using std::move(param)
}

// Typical function implementations with universal reference:
template <typename T>
void doWork(T&& param)             // forward => copy and move
{
  // ops and exprs using std::forward<T>(param)
}

关键是当我们采用右值引用时，我们知道我们有一个右值，所以我们应std::move来保留它是一个右值的事实。当我们采用通用引用（T&&，其中T是推导类型）时，我们希望std::forward保留它可能是左值或右值的事实。

所以问题是：因为std::forward保留传递给函数的值是左值还是左值，而std::move只是将其参数转换为右值，我们可以使用{{ 1}}无处不在？ std::forward在我们使用std::forward的所有情况下都会std::move表现得像std::move，或者Meyers的概括错过了一些重要的行为差异？

我并不是说任何人都应该这样做，因为正如迈耶斯所说，这完全是非惯用的，但以下也是std::move的有效用法：

void doWork(Widget&& param)         // move
{
  // ops and exprs using std::forward<Widget>(param)
}

Answer 1

两者是非常不同的互补工具。

std::move 推断参数，并无条件地创建一个右值表达式。这适用于实际的对象或变量。
std::forward采用强制模板参数（您必须指定此参数！）并根据类型（通过添加&&和“魔法”创建一个左值或右值表达式崩溃规则）。这仅适用于推导的模板化函数参数。

以下示例可能会更好地说明这一点：

#include <utility>
#include <memory>
#include <vector>
#include "foo.hpp"

std::vector<std::unique_ptr<Foo>> v;

template <typename T, typename ...Args>
std::unique_ptr<T> make_unique(Args &&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));  // #1
}

int main()
{
    {
        std::unique_ptr<Foo> p(new Foo('a', true, Bar(1,2,3)));
        v.push_back(std::move(p));                                  // #2
    }

    {
        v.push_back(make_unique<Foo>('b', false, Bar(5,6,7)));      // #3
    }

    {
        Bar b(4,5,6);
        char c = 'x';
        v.push_back(make_unique<Foo>(c, b.ready(), b));             // #4
    }
}

在情境＃2中，我们有一个现有的具体对象p，我们希望无条件地从它移动。只有std::move才有意义。没有什么可以＆＃34;转发＆＃34;这里。我们有一个命名变量，我们希望从中移动。

另一方面，情境＃1接受任何类型的参数列表，并且每个参数需要作为与原始调用中相同的值类别转发。例如，在＃3中，参数是临时表达式，因此它们将作为rvalues转发。但是我们也可以在构造函数调用中混合使用命名对象，如情况＃4，然后我们需要转发为左值。

Answer 2

是的，如果param是Widget&&，则以下三个表达式是等效的（假设Widget不是引用类型）：

std::move(param)
std::forward<Widget>(param)
static_cast<Widget&&>(param)

一般情况下（当Widget可能是参考时），std::move(param)等同于以下两个表达式：

std::forward<std::remove_reference<Widget>::type>(param)
static_cast<std::remove_reference<Widget>::type&&>(param)

请注意移动内容的std::move有多好。 std::forward的要点是它与模板类型扣除规则混合得很好：

template<typename T>
void foo(T&& t) {
    std::forward<T>(t);
    std::move(t);
}

int main() {
    int a{};
    int const b{};
               //Deduced T   Signature    Result of `forward<T>` Result of `move`
    foo(a);    //int&        foo(int&)       lvalue int          xvalue int
    foo(b);    //int const&  foo(int const&) lvalue int const    xvalue int const
    foo(int{});//int         foo(int&&)      xvalue int          xvalue int
}

我可以/通常使用std :: forward而不是std :: move吗？

2 个答案: