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

Question

我一直在观看Scott Meyers 关于 C++和2012 年之后的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简单地将其参数转换为右值,我们可以只使用std::forward到处吗？会std::forward表现得像std::move在所有情况下,我们会使用std::move,还是有由迈尔斯泛化错过了在行为上一些重要的区别是什么？

我并不是说任何人都应该这样做,因为正如迈耶斯所说的那样,它完全不是惯用的,但以下也是有效用途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意义.这里没有什么可以"前进"的.我们有一个命名变量,我们希望从中移动.

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

Answer 2

是的,如果param是a 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
}