c++ - 为什么我们不能用右值 volatile int&& 初始化对 const int 的引用？

Question

我写了下面的例子:

#include <iostream>

volatile int&& bar()
{
    return 1;
}

int main()
{
    const int& i = bar(); //error: binding of reference to type 'const int' 
                          //to a value of type 'volatile int' drops qualifiers
}

DEMO

但是如果我们用 int 替换 int&& 它工作正常:

#include <iostream>

volatile int bar()
{
    return 1;
}

int main()
{
    const int& i = bar(); //OK

}

DEMO

这不是很清楚。标准所说的是 (8.5.3/5 [dcl.init.ref]):

A reference to type “cv1 T1” is initialized by an expression of type “cv2 T2” as follows:

— If the reference is an lvalue reference and the initializer expression

• is an lvalue (but is not a bit-field), and “cv1 T1” is reference-compatible with “cv2 T2,” or

• has a class type (i.e., T2 is a class type), where T1 is not reference-related to T2, and can be converted to an lvalue of type “cv3 T3,” where “cv1 T1” is reference-compatible with “cv3 T3” 108 (this conversion is selected by enumerating the applicable conversion functions (13.3.1.6) and choosing the best one through overload resolution (13.3)), then the reference is bound to the initializer expression lvalue in the first case and to the lvalue result of the conversion in the second case (or, in either case, to the appropriate base class subobject of the object).

[...]

— Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i.e., cv1 shall be const), or the reference shall be an rvalue reference.

好吧，在第一个示例中，我们有一个 volatile int&& 类型的右值。 'otherwise' 情况适用于这两个示例。但是 5/5 [expr] 说:

If an expression initially has the type “reference to T” (8.3.2, 8.5.3), the type is adjusted to T prior to any further analysis

因此，本质上我们有一个 volatile int 类型的右值，而不是 volatile int&&，这意味着这两个示例将以相同的方式工作。

Answer 1

这两种情况的区别在于，在情况 1 中，引用直接绑定(bind)，而在情况 2 中，它不直接绑定(bind)(即引用绑定(bind)到一个临时对象；定义可以在[dcl.init.ref] 的最后一段)。

直接绑定(bind)失败，因为 T2 是 volatile 限定的而 T1 不是(在标准术语中，T1 不是 与 T2 引用兼容。

间接绑定(bind)成功是因为当一个临时的int被bar()返回的引用初始化时，这个临时的不是volatile。 (临时文件的类型为 cv1 T1)。

---

看看为什么案例 1 是直接绑定(bind)。首先，bar() 在这里是一个xvalue。参见 [basic.lval]/1“调用返回类型为右值引用的函数的结果是一个 xvalue”。

来自[dcl.init.ref]/5:

• If the reference is an lvalue reference and the initializer expression [is an lvalue] or [has class type]

不适用:初始化器是一个 xvalue(不是左值)，它是一个引用，所以它没有类类型。

• Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i.e., cv1 shall be const), or the reference shall be an rvalue reference

这确实适用:const int & 是对非 volatile 常量类型的左值引用。沿着这棵树走下去:

If the initializer expression

• is an xvalue (but not a bit-field), class prvalue, array prvalue or function lvalue and “cv1 T1” is reference-compatible with “cv2 T2”, or
• [another case]

then the reference is bound to the value of the initializer expression in the first case [...]

这确实适用，因为 bar() 是一个 xvalue。所以引用绑定(bind)到 xvalue，这被称为直接绑定(bind)，因为它没有绑定(bind)到临时值。

---

注意。所有标准引用均来自 C++14 (N3936)。由于 DR1288，此部分从 C++11 更改。