重载 const 和非常量转换运算符返回数组类型时的 MSVC 错误 C2593

Question

最近，我尝试使用转换运算符来替代operator []。

喜欢下面的代码：

#include <iostream>

class foo
{
public:
    using type = int[1];

public:
    operator type       &()       { return data; }
    operator type const &() const { return data; }

private:
    type data;
};

int main()
{
    foo f;
    f[0] = 1;                        // error happens here
    std::cout << f[0] << std::endl;
    return 0;
}

我发现它适用于 G++，但不适用于 MSVCv141(2017)。

MSVC 报告：

error C2593: 'operator [' is ambiguous
note: could be 'built-in C++ operator[(foo::type, int)'
note: or       'built-in C++ operator[(const foo::type, int)'
note: while trying to match the argument list '(foo, int)'

那是 MSVC 的错误还是其他什么？以及如何解决？

Answer 1

这是一个 MSVC 错误。候选人并不模棱两可。我想解决方法是提供一个 named 到数组的转换函数，或者只提供一个用户定义的operator[]。

---

使用运算符时，我们有[over.match.oper]:

如果任一操作数的类型是类或枚举，则可能会声明实现此运算符的用户定义的运算符函数，或者可能需要用户定义的转换将操作数转换为适合的类型内置运算符。

在f[0] 中，f 具有类类型，因此我们考虑用户定义的运算符函数或用户定义的转换。前者没有，后者有两个。两者都是可行的候选人：

f.operator type&()[1];       // ok
f.operator type const&()[1]; // also ok

因此，我们必须执行重载决议来挑选最佳可行的候选人。两者的不同在于隐式对象参数。根据[over.match.funcs]：

为了使实参和形参列表在这个异构集合中具有可比性，成员函数被认为有一个额外的形参，称为隐式对象形参，它表示已调用成员函数的对象。出于重载决议的目的，静态和非静态成员函数都具有隐式对象参数，但构造函数没有。 [...]

对于非静态成员函数，隐含对象参数的类型为

• “对 cv X 的左值引用”适用于未使用 ref-qualifier 或 & ref-qualifier 声明的函数

[ ... ] 其中 X 是函数所属的类，cv 是成员函数声明上的 cv 限定。 [ ... ] 对于转换函数，该函数被认为是隐含对象参数的类的成员，以便定义隐含对象参数的类型。

所以这里的重载决议表现得好像我们有：

type&       __op(foo& );       // #1
type const& __op(foo const& ); // #2

__op(f);

此时，ICS ranking rules 告诉我们：

如果 [ ... ] S1 和 S2 是引用绑定，则标准转换序列 S1 是比标准转换序列 S2 更好的转换序列，并且引用所引用的类型除了顶级 cv 限定符之外是相同的类型，并且由 S2 初始化的引用所引用的类型比由 S1 初始化的引用所引用的类型更具有 cv 限定。

#1 中的引用绑定比 #2 中的引用绑定的 cv 限定更少，因此它是更好的匹配。由于这是一个更好的匹配，我们最终得到了一个独特的、最佳可行的函数，并且调用格式正确。

---

此外，让转换运算符返回指向数组的指针或引用在这里并不重要。基本规则相同，但 MSVC allows the former。 MSVC 也允许这样做：

struct  foo
{
    using type = int[1];
    operator type&       ()       { return data; }
    operator type const& () const { return data; }
    type data;
};

void call(int (&)[1]); // #1
void call(int const (&)[1]); // #2

int main()
{
    foo f;
    call(f); // correctly calls #1
}