错误：'operator[]' 的模糊重载

Question

我有一个错误我不明白。 以下片段编译

#include <iostream>

class Foo
{
    std::string m_name;

public:

    explicit Foo(std::string const& name):m_name{name}{}

    Foo operator[](int index) const {std::cout<<"size_t const\n"; return Foo{m_name};}
    Foo operator[](std::string const& name) const { std::cout<<"str const\n"; return Foo{name}; }
};

int main()
{
    Foo foo{"Cool"};
        
    foo[0]; 
    foo[1]; 
    
    return 0;
}

但是当我重载 operator[](std::string const&)

 时，以下内容不会为 

index=0

编译

#include <iostream>

class Foo
{
    std::string m_name;

public:

    explicit Foo(std::string const& name):m_name{name}{}

    Foo operator[](int index) const {std::cout<<"size_t const\n"; return Foo{m_name};}
    Foo operator[](std::string const& name) const { std::cout<<"str const\n"; return Foo{name}; }
    Foo operator[](std::string const& name) { std::cout<<"str non const\n";  return Foo{name}; } //doesn't compile with
};

int main()
{
    Foo foo{"Cool"};
        
    foo[0]; //doesn't compile
    foo[1]; //compile
    
    
    return 0;
}

在这种情况下，我有以下编译错误：

main.cpp: In function 'int main()':
main.cpp:25:8: error: ambiguous overload for 'operator[]' (operand types are 'Foo' and 'int')
  25 |     foo[0]; //doesn't compile
main.cpp:12:5: note: candidate: 'Foo Foo::operator[](int) const'
  12 | Foo operator[](int index) const {std::cout<<"size_t const\n"; return Foo{m_name};}
main.cpp:13:5: note: candidate: 'Foo Foo::operator[](const std::string&) const'
  13 | Foo operator[](std::string const& name) const { std::cout<<"str const\n"; return Foo{name}; }
main.cpp:14:5: note: candidate: 'Foo Foo::operator[](const std::string&)'
  14 | Foo operator[](std::string const& name) { std::cout<<"str non const\n";  return Foo{name}; } //doesn't compile with     

1. 为什么添加带有

   std::string

   参数的重载会使

   foo[0]

   模棱两可？
2. 为什么问题只出现在索引 0 上？

Answer 1

问题是

std::string::string(const char*)

是不显式（并且

0

是一个空指针常量）这意味着重载

Foo::Foo operator[](int) const

和

Foo::Foo operator[](const std::string&)

都是可行的但具有相同的等级。这反过来意味着调用是模棱两可的，因为它们都不比另一个好。

特别是，

Foo::Foo operator[](int) const

需要对其第一个隐式参数进行转换，但不需要对其第二个

int

参数进行转换。另一方面，

Foo::Foo operator[](const std::string&)

不需要对其第一个隐式参数进行转换，但需要使用构造函数 0 进行从

std::string

到

std::string::string(const char*)

的

隐式转换

。由于这些重载中没有一个比另一个更好，所以调用是模棱两可的。