C ++重载决议和常量

Question

（所有测试均在 Microsoft (R) C/C++ 针对 x86 优化编译器版本 19.00.24215.1）

考虑这个最小的例子：

struct myString
{
    operator const char *( ) const { return &dummy; }
    char& operator[]( unsigned int ) { return dummy; }
    const char& operator[]( unsigned int ) const { return dummy; }

    char dummy;
};

int main()
{
    myString str;
    const char myChar = 'a';

    if( str[(int) 0] == myChar ) return 0; //error, multiple valid overloads
}

根据重载解析规则（来自cppreference）

F1 is determined to be a better function than F2 if implicit conversions for all arguments of F1 are not worse than the implicit conversions for all arguments of F2, and

1) there is at least one argument of F1 whose implicit conversion is better than the corresponding implicit conversion for that argument of F2

2) or. if not that, (only in context of non-class initialization by conversion), the standard conversion sequence from the return type of F1 to the type being initialized is better than the standard conversion sequence from the return type of F2

char& operator[]( unsigned int )应该更好，根据1）。

两个参数中（this = myString）根本不需要转换，而operator const char *( ) const将其转换为const char*而const char& operator[]( unsigned int ) const将其转换为const myString，因此有一个没有任何隐式转换的参数，恰好是最好的转换

但是我的编译器报出以下错误：

1>  [///]\sandbox\sandbox\sandbox.cpp(29): error C2666: 'myString::operator []': 3 overloads have similar conversions
1>  [///]\sandbox\sandbox\sandbox.cpp(19): note: could be 'const char &myString::operator [](unsigned int) const'
1>  [///]\sandbox\sandbox\sandbox.cpp(18): note: or       'char &myString::operator [](unsigned int)'
1>  [///]\sandbox\sandbox\sandbox.cpp(29): note: while trying to match the argument list '(myString, int)'

另请注意，使用 if( str[0u] == myChar ) return 0; 或删除 operator const char *( ) const 可解决错误

为什么这里有错误，我对重载解析规则有什么误解？

编辑：这可能是此版本中的可视化 C++ 错误，对此有任何明确的确认吗？

Answer 1

这是问题的缩小版本，在 all compilers I threw at it 上重现。

#include <stddef.h>

struct myString
{
    operator char *( );
    char& operator[]( unsigned ptrdiff_t );
};

int main()
{
    myString str;
    if( str[(ptrdiff_t) 0] == 'a' ) return 0; //error, multiple valid overloads
}

基本上，您有两个候选函数可以为 bool operator==(char,char) 获得 char：[over.match.oper]/3

• char& myString::operator[]( unsigned ptrdiff_t ) ([over.match.oper]/3.1 => [over.sub])
• char& operator[]( char*, ptrdiff_t) ([over.match.oper]/3.3 => [over.built]/14)

请注意，如果 myString::operator[] 使用 ptrdiff_t 而不是 unsigned ptrdiff_t，那么它将隐藏每个 [over.built]/1 的内置运算符。因此，如果您想做的只是避免此类问题，只需确保任何 operator[] 重载采用整数值，采用 ptrdiff_t.

我将跳过可行性检查 [over.match.viable]，直接进入转化排名。

char& myString::operator[]( unsigned ptrdiff_t )

为了重载，this被认为有一个前导隐式对象参数，所以要匹配的签名是 (myString&, unsigned ptrdiff_t)

myString& => myString&

标准转换序列：Identity（排序：精确匹配）-直接绑定引用

ptrdiff_t => unsigned ptrdiff_t

标准转换序列：Lvalue Transformation -> Integral conversion（等级：转换）-有符号左值到无符号纯右值

char& operator[]( char*, ptrdiff_t)

myString& => char*

用户自定义转换顺序：Identity + operator char*(myString&)

请注意，根据 [over.match.oper]/7 我们没有得到第二个标准转换序列。

ptrdiff_t => ptrdiff_t

标准转换序列：Identity（Rank：Exact match）

Best viable function

第一个参数

标准转换序列优于用户定义的转换序列([over.ics.rank]/2.1)

第二个参数

排名转换比排名完全匹配差 ([over.ics.rank]/3.2.2)

结果

我们无法满足requirement

if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2)

所以这两个函数都不是更好的函数。

因此，根据 [over.match.best]/2 它是 模棱两可的 。

---

如何解决这个问题？

嗯，最简单的解决方案是 从不 让 operator[] 重载的参数可以由其他东西从 ptrdiff_t 转换成比 完全匹配 排名的转化。查看 the conversions table 似乎意味着您应该始终将 operator[] 成员函数声明为 X& T::operator[]( ptrdiff_t )。这涵盖了 "Act like an array" 的常见用例。如上所述，通过将内置下标运算符从 table 中移除，精确使用 ptrdiff_t 甚至会抑制 搜索 以寻找 operator T* 候选对象。 =65=]

另一种选择是不为 class 定义 T1 operator[] 和 operator T2*，其中 T1 和 T2 可能都满足相同的要求（可能是隐式的）函数调用的参数。这涵盖了您将 operator[] 用于巧妙的语法事物，并最终得到 T T::operator[](X) 之类的情况。例如，如果 X::operator ptrdiff_t() 存在，T::operator T*() 也存在，那么你又模棱两可了。

我能想象的 T::operator T*() 的唯一用例是，如果您希望您的类型隐式转换为指向自身的指针，如函数。 不要那样做...