为什么转发引用需要 std::forward [重复]

Question

在这样的函数模板中

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

如果foo 使用右值引用调用，x 不是在foo 中的右值引用吗？如果使用左值引用调用 foo，则无论如何都不需要强制转换，因为x 也将是foo 内的左值引用。同样T 会被推导出为左值引用类型，所以std::forward<T> 不会改变x 的类型。

我使用boost::typeindex 进行了测试，我得到的类型完全相同，有无std::forward<T>。

#include <iostream>
#include <utility>

#include <boost/type_index.hpp>

using std::cout;
using std::endl;

template <typename T> struct __ { };

template <typename T> struct prt_type { };
template <typename T>
std::ostream& operator<<(std::ostream& os, prt_type<T>) {
  os << "\033[1;35m" << boost::typeindex::type_id<T>().pretty_name()
     << "\033[0m";
  return os;
}

template <typename T>
void foo(T&& x) {
  cout << prt_type<__<T>>{} << endl;
  cout << prt_type<__<decltype(x)>>{} << endl;
  cout << prt_type<__<decltype(std::forward<T>(x))>>{} << endl;
  cout << endl;
}

int main(int argc, char* argv[])
{
  foo(1);

  int i = 2;
  foo (i);

  const int j = 3;
  foo(j);

  foo(std::move(i));

  return 0;
}

g++ -Wall test.cc && ./a.out 与 gcc 6.2.0 和 boost 1.62.0 的输出是

__<int>
__<int&&>
__<int&&>

__<int&>
__<int&>
__<int&>

__<int const&>
__<int const&>
__<int const&>

__<int>
__<int&&>
__<int&&>

编辑：我找到了这个答案：https://stackoverflow.com/a/27409428/2640636 显然，

只要你给参数一个名字，它就是一个左值。

我的问题是，为什么选择这种行为而不是保留右值引用作为右值，即使它们被赋予名称？在我看来，整个转发难题都可以通过这种方式规避。

Edit2：我不是在问std::forward 的什么。我在问为什么需要它。

Answer 1

x 不是 foo 内部的右值引用吗？

不，x 是foo 中的一个左值（它有一个名称和一个地址），类型为右值引用。结合参考折叠规则和模板类型推导规则，您会发现您需要std::forward 才能获得正确的参考类型。

基本上，如果你作为x 传递给的是一个左值，比如int，那么T 会被推导出为int&。然后int && & 变为int&（由于引用折叠规则），即左值引用。

另一方面，如果你传递一个右值，比如42，那么T被推导出为int，所以最后你有一个int&&作为x的类型，即a右值。基本上这就是 std::forward 所做的：将结果转换为 T&&，就像

static_cast<T&&>(x)

由于引用折叠规则，它变为T&& 或T&。

它的用处在泛型代码中变得显而易见，您可能事先不知道您将获得右值还是左值。如果您不调用std::forward 而只调用f(x)，那么x 将始终是左值，因此您将在需要时丢失移动语义，最终可能会出现 un-必要的副本等。

您可以看到差异的简单示例：

#include <iostream>

struct X
{
    X() = default;
    X(X&&) {std::cout << "Moving...\n";};
    X(const X&) {std::cout << "Copying...\n";}
};

template <typename T>
void f1(T&& x)
{
    g(std::forward<T>(x));
}

template <typename T>
void f2(T&& x)
{
    g(x);
}

template <typename T>
void g(T x)
{ }

int main()
{
    X x;
    std::cout << "with std::forward\n";
    f1(X{}); // moving

    std::cout << "without std::forward\n";
    f2(X{}); // copying
}

Live on Coliru

Answer 2

你真的不希望你的参数被自动移动到调用的函数中。考虑这个函数：

template <typename T>
void foo(T&& x) {
  bar(x);
  baz(x);
  global::y = std::forward<T>(x);
}

现在你真的不想要自动移动到bar 和一个空参数到baz。

要求您指定是否以及何时移动或转发参数的当前规则并非偶然。

Answer 3

我得到完全相同的类型有和没有std::forward<T>

...不是吗？你自己的输出证明你错了：

__<int>    // T
__<int&&>  // decltype(x)
__<int&&>  // std::forward<T>(x)

如果不使用std::forward<T> 或decltype(x)，您将获得int 而不是int&&。这可能会不经意地“传播x 的右值性” - 考虑这个例子：

void foo(int&)  { cout << "int&\n"; }
void foo(int&&) { cout << "int&&\n"; }

template <typename T>
void without_forward(T&& x)
{
    foo(x);
//      ^
//  `x` is an lvalue!
}

template <typename T>
void with_forward(T&& x)
{
//  `std::forward` casts `x` to `int&&`.
//      vvvvvvvvvvvvvvvvvv
    foo(std::forward<T>(x));
//                      ^
//          `x` is an lvalue!
}

template <typename T>
void with_decltype_cast(T&& x)
{
// `decltype(x)` is `int&&`. `x` is casted to `int&&`.
//      vvvvvvvvvvv
    foo(decltype(x)(x));
//                  ^
//          `x` is an lvalue!
}

int main()
{
    without_forward(1);    // prints "int&"
    with_forward(1);       // prints "int&&"
    with_decltype_cast(1); // prints "int&&"
}

wandbox example

Answer 4

x 是 r-value 与 x 具有 r-value-reference 类型不同。

R-value 是 expression 的属性，而 r-value-reference 是其 type 的属性。

如果您实际上尝试将作为 r 值引用的变量传递给函数，则会将其视为左值。 decltype 误导您。 Try it and see:

#include <iostream>
#include <typeinfo>
using namespace std;

template<class T> struct wrap { };

template<class T>
void bar(T &&value) { std::cout << " vs. " << typeid(wrap<T>).name() << std::endl; }

template<class T>
void foo(T &&value) { std::cout << typeid(wrap<T>).name(); return bar(value); }

int main()
{
    int i = 1;
    foo(static_cast<int &>(i));
    foo(static_cast<int const &>(i));
    foo(static_cast<int &&>(i));
    foo(static_cast<int const &&>(i));
}

输出：

4wrapIRiE   vs. 4wrapIRiE
4wrapIRKiE vs. 4wrapIRKiE
4wrapIiE      vs. 4wrapIRiE（这些应该匹配！）
4wrapIKiE   vs. 4wrapIRKiE （这些应该匹配！）