c++ - 为什么作为返回类型的右值引用不能初始化非常量引用？

Question

我读了this问题，我知道右值引用是左值。

然而，对于这段代码，例子1，

int &&fun() {
    return 1;
}

int main() {
    int &a = fun();
}

当我编译它时:

 error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int'

所以 C++ 编译器告诉我 fun 的返回类型是右值。

右值引用如何变成右值？

我认为编译器应该以相同的方式对待左值引用和右值引用，但是这段代码，示例 2，

int & fun(){
    int b;
    return b;
}
int main(){
    int & a=fun();
}

可以编译(尽管如此，我收到警告)。

我想也许 fun 的返回类型在某些时候发生了变化。

尝试编译示例 3:

int &&fun() {
    return 1;
}

int main() {
    decltype(fun()) b = 1;
}

编译成功。所以我可以说 fun 的返回类型实际上是一个右值引用。

那么，为什么右值引用会变成右值？

这是示例 4:

int &&a = 1;
int &b = a;

它编译并告诉我们右值引用可以绑定(bind)到左值引用。

现在，那两个问题呢:

1. 在示例 1 中，fun() 是右值吗？
2. 在示例 1 中，fun() 是右值引用吗？

示例 3 告诉我们 fun() 是右值引用，示例 4 告诉我们右值引用可以绑定(bind)到左值引用(const 和非 const)。那为什么示例 1 中的 fun() 不能绑定(bind)到左值引用？

示例 4 也表明右值引用是左值，但是示例 1 中的编译错误告诉我们 fun() 在示例 3 中被证明是右值引用，是一个右值。那么，右值引用是左值还是右值？

如果原因是 fun() 只是一个表达式，暂时存在，马上就消亡，为什么不考虑示例 2 中的 fun()一个右值，同时它也只是一个没有名字的表达式？返回左值引用和右值引用的函数的函数表达式有什么区别？

Answer 1

I know that an rvalue reference is an lvalue.

你在谈论两个不同的东西:type 和 value category .例如

int&& ri = 0; // ri's type is rvalue reference (to int)
              // ri's value category is lvalue; it's a named variable.

给定你的第一个样本，什么 fun() returns 是一个 xvalue，属于 rvalues。

The following expressions are xvalue expressions:

• a function call or an overloaded operator expression, whose return type is rvalue reference to object, such as std::move(x);

然后，

int &a = fun(); // fails; lvalue-reference can't bind to rvalue

在第二个样本中，什么fun()返回是一个左值，

The following expressions are lvalue expressions:

• a function call or an overloaded operator expression, whose return type is lvalue reference, such as std::getline(std::cin, str),std::cout << 1, str1 = str2, or ++it;

然后

int & a=fun(); // fine; lvalue-reference could bind to lvalue

在第三个样本中，

decltype(fun()) b = 1; // the return type of fun() is rvalue-reference;
                       // this has nothing to do with the value category of its return value
                       // b's type is rvalue-reference too, btw its value category is lvalue

在第 4 个样本中，

int &&a = 1; // fine; rvalue-reference could bind to rvalue
             // a's type is rvalue-reference, its value category is lvalue
int &b = a;  // fine; lvalue-reference could bind to lvalue
             // b's type is lvalue-reference, its value category is lvalue