考虑这段代码:

int **p = 0;

class S {
public:
    explicit operator int**&() {
        return p;
    }
};

int main() {
    S a;
    int *const*&b (a); // error in both g++-7 and clang-5.0 with "-std=c++17"
    return 0;
}

你会同意

• 从 int** 到 int*const* 的限定转换是可能的，并且
• int *const*&b (a) 是一个直接初始化。

首先，我们引用 n4700 中的 11.6.3 第 5 段 [dcl.init.ref] .

A reference to type “cv1 T1 (= int*const*)” is initialized by an expression of type “cv2 T2 (= S)” as follows:

• If the reference is an lvalue reference and the initializer expression
  • ...
  • 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” (this conversion is selected by enumerating the applicable conversion functions (16.3.1.6) and choosing the best one through overload resolution (16.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...

在这里，我们期望 T3 为 int*const*。 如上所述，根据 16.3 确定是否可能转换.1.6，第 1 段 [over.match.ref]。

... Assuming that “reference to cv1 T” is the type of the reference being initialized, and “cv S” is the type of the initializer expression, with S a class type, the candidate functions are selected as follows:

• ... For direct-initialization, those explicit conversion functions that are not hidden within S and yield type “lvalue reference to cv2 T2” or “cv2 T2” or “rvalue reference to cv2 T2”, respectively, where T2 is the same type as T or can be converted to type T with a qualification conversion are also candidate functions.

此处，S::operator int**& 产生“对 T2 (= int**) 的左值引用”，它可以转换为T (= int*const*) 通过限定转换。 这里，我们可以说转换是可能的，但该程序在 g++-7 和 clang-5.0 中都不被接受.这是为什么？

最佳答案

我们正在寻找的引用初始化规则是[dcl.init.ref] :

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

我们有 cv1 T1 作为 int* const* 和 cv2 T2作为 S。然后我们仔细阅读以下部分:

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” (this conversion is selected by enumerating the applicable conversion functions ([over.match.ref]) and choosing the best one through overload resolution),

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).

我们的引用是左值引用。初始化表达式是左值，但两种类型不是 reference-compatible ，因此第一个项目符号不适用。

初始化表达式确实有非引用相关的类类型，但它不能转换为引用兼容的类型。引用兼容部分很重要。 int** 与 int* const* 不引用兼容，虽然前者可以转换为后者，但结果不会是左值 - 这也是必需的。

因此，本节不适用，我们 move on .

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.

我们的引用不满足这两个条件，因此初始化格式错误。

此失败的更简单版本是:

int* pi;
int const*& r = pi; // error

当我们有一个对非常量类型的左值引用时，我们不能进行限定转换。

关于c++ - 为什么这个引用绑定(bind)格式错误？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47994079/