为什么右值引用被通用引用变成左值引用

Question

我想当通用引用参数与右值引用参数匹配时，会返回一个右值引用参数。但是，我的测试表明，右值引用被通用引用函数模板变成了左值引用。为什么会这样？

#include <iostream>
#include <type_traits>
using namespace std;
template <typename T>
T f1(T&&t) {  //<-----this is a universal reference
  cout << "is_lvalue reference:" << is_lvalue_reference<T>::value << endl;
  cout << "is_rvalue reference:" << is_rvalue_reference<T>::value << endl;
  cout << "is_reference:"        << is_reference<T>::value        << endl;
  return t;
}
void f2(int&& t) {
  cout << "f2 is_lvalue reference:" << is_lvalue_reference<decltype(t)>::value << endl;
  cout << "f2 is_rvalue reference:" << is_rvalue_reference<decltype(t)>::value << endl;
  cout << "f2 is_reference:" << is_reference<decltype(t)>::value << endl;
  f1(t);

}

int main()
{
  f2(5);
  return 0;
}

在 GCC 和 VC++2010 中，结果如下：

f2 is_lvalue reference:0
f2 is_rvalue reference:1
f2 is_reference:1
is_lvalue reference:1
is_rvalue reference:0
is_reference:1

也就是说，f2 中的参数t 是一个右值引用，但是当传递给f1 时，该参数变成了一个左值引用。它不应该保留f1 中的右值吗？

Answer 1

原因是命名的右值引用被视为左值。

在将 t 传递给 f1 时，您应该在 f2 中使用 std::move 以保留右值性：

void f2(int&& t) {
    f1(std::move(t));
}

Here你可以找到一个很好的解释。

Answer 2

调用f1(t)，参数是表达式t。不是static_cast<decltype(t)>(t) 什么的。你对decltype(t)的检查与f1(t)的调用无关。

表达式t 具有int 类型和值类别lvalue。 （经验法则是，如果你可以获取一个表达式的地址，那么它就是一个左值，你当然可以写成&t）。引用变量最初被声明为引用的“信息”只能通过decltype 检查看到。

由于f1 是用左值调用的，所以T 被推导出为int&。

注意。如果您想看到is_rvalue_reference 在f1 中为真，您可能希望f1 也使用decltype(t) 而不是T。对于右值参数，T 推断为非引用类型，例如如果你通过修复f2 来修复f1(std::move(t)); 那么f1 的T 是int 和decltype(t) 在f1 是int&&。

Answer 3

在学习了 C++11 标准之后，我对我的 f1(t); 在 f2 之后发生的事情有了一个模糊的概念。我在这里描述一下，看看我是否正确：

1. 在f2中，t是int&&类型的左值（不是int，这是一个重要的区别）

2. 调用f1(t); 导致类型被推导如下：

   2.1 当f1 中的T 被赋予一个左值时，它被推断为该左值类型或int&& & 的引用

   2.2 引用折叠导致int&& & 变为int &。这是T 的值。

3. 由于f1的参数声明为T&&，所以f1中的参数t的类型为int & &&。所以引用折叠第二次发生以推断t的类型为int &。

4. 因此 T=int & 和参数类型 t 是 int &。即参数t是int &类型的左值

有什么意见吗？

Answer 4

使用 std::forward 将 t 保留为右值。

void f2(int&& t) {
  //....
  f1(std::forward<int>(t));
}

t 参数作为右值传递并推导出为 int 类型。 （看扣分是怎么做的here）

std::forward(t) 返回一个 int&& 类型的右值，以便调用 f1(int&&)

没有 std::forward(t)，f1(t) 接受 int 类型的参数并调用 f1(int&)

更新：请注意两者的区别

 is_lvalue_reference<T> and is_lvalue_reference<decltype<t>>. 

在模板中，T是根据函数参数推导出来的，而t的值类别总是f2中的左值，而

forward<int>(t) and move(t) 

总是右值。

#include <iostream>
#include <type_traits>

class A {};


template <typename T>
T f0(T& t) {  //<-----this is a universal reference
    std::cout<< "f0 lvalue"<<'\n';

    // take T as template argument, it is type int, so not rvalue, not lvalue.
//  std::cout << "is_lvalue reference:" << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<T>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<T>::value        << std::endl;
    return t;
}

template <typename T>
T f0(T&&t) {  //<-----this is a universal reference
    std::cout<< "f0 rvalue"<<'\n';
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<T>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<T>::value        << std::endl;
    return t;
}

template <typename T>
T f1(T& t) {  //<-----this is a universal reference
    std::cout<< "f1 lvalue"<<'\n';

    // take T as template argument, it is type int, so not rvalue, not lvalue.
//  std::cout << "is_lvalue reference:" << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<decltype(t)>::value        << std::endl;
    return t;
}

template <typename T>
T f1(T&&t) {  //<-----this is a universal reference
    std::cout<< "f1 rvalue"<<'\n';
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<decltype(t)>::value        << std::endl;
    return t;
}

void f2(int&&t) {  //<-----this is a universal reference
    std::cout<< "f2 rvalue"<<'\n';
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<decltype(t)>::value        << std::endl;


    f1(std::forward<int>(t));   // T is deduced as int for f(T&&), type int is not rvalue, nor lvalue, t is rvalue
    f1(std::move(t));           // T is deduced as int for f(T&&), type int is not rvalue, nor lvalue, t is rvalue
    f1(t);                      // T is deduced as int for f(T&),  type int is not rvalue, nor lvalue, t is lvalue
                                //if f1(T&) not exist, then f1(t) will call f1(T&&), T is deduced as int&, type int& is lvalue, t is lvalue


    f0(std::forward<int>(t));   // T is deduced as int for f(T&&), type int is not rvalue, nor lvalue, t is rvalue
    f0(std::move(t));           // T is deduced as int for f(T&&), type int is not rvalue, nor lvalue, t is rvalue
    f0(t);                      // T is deduced as int for f(T&),  type int is not rvalue, nor lvalue, t is lvalue
                                //if f0(T&) not exist, then f0(t) will call f0(T&&), T is deduced as int&, type int& is lvalue, t is lvalue
}




void test_rvalue()
{

    f2(5);
    std::cout << std::boolalpha;
    std::cout << std::is_lvalue_reference<A>::value << '\n';        // A is not lvalue
    std::cout << std::is_rvalue_reference<A>::value << '\n';        // A is not rvalue
    std::cout << std::is_lvalue_reference<A&>::value << '\n';       // A& is lvalue
    std::cout << std::is_rvalue_reference<A&&>::value << '\n';      // A&& is rvalue
    std::cout << std::is_lvalue_reference<int>::value << '\n';      // int is not lvalue
    std::cout << std::is_rvalue_reference<int>::value << '\n';      // int is not rvalue
    std::cout << std::is_lvalue_reference<int&>::value << '\n';     // int& is lvalue
    std::cout << std::is_rvalue_reference<int&&>::value << '\n';    // int&& is rvalue

}