为什么可以通过重载决议来解决的程序因不明确而被拒绝？

以下程序因不明确而被 gcc 拒绝：

struct Aint 
{
    virtual void foo(int);
};

struct Astring 
{
    virtual void foo(std::string);
};

struct A: public Aint, public Astring {};

int main()
{
  std::string s;

  A a;
  a.foo(s);

  return 0; 
}

> vt.cpp: In function ‘int main()’: vt.cpp:13:9: error: request for
> member ‘foo’ is ambiguous
>        a.foo(s);
>          ^ vt.cpp:5:34: note: candidates are: virtual void Astring::foo(std::__cxx11::string)
>      struct Astring {virtual void foo(std::string);};
>                                   ^ vt.cpp:4:31: note:                 virtual void Aint::foo(int)
>      struct Aint {virtual void foo(int);};

Clang 出于同样的原因始终拒绝该计划：

clang -std=c++1y -c vt.cpp 

vt.cpp:13:9: error: member 'foo' found in multiple base classes of different types
      a.foo(s);
        ^
vt.cpp:4:31: note: member found by ambiguous name lookup
    struct Aint {virtual void foo(int);};
                              ^
vt.cpp:5:34: note: member found by ambiguous name lookup
    struct Astring {virtual void foo(std::string);};

我不完全确定我是否正确理解了 10.2 节中的查找规则，因此我将按照以下步骤遍历规则来计算查找集 S(foo, A)：

1. A does not contain `foo`, so rule 5 applies and S(foo, A) is initially empty. We need to calculate the lookup sets S(foo, Aint) and S(foo, Afloat) and merge them to S(foo, A) = {}
2. S(foo, Aint) = {Aint::foo}
3. S(foo, Afloat) = {Afloat::foo}
4. Merge S(foo, Aint) = {Aint::foo} into S(foo, A) = {} to get S(foo, A) = {Aint::foo} (second case of 6.1)
5. Merge S(foo, Afloat) = {Afloat::foo} into {Aint::foo}. This create an ambiguous lookup set because of rule 6.2

结果集是无效集，因此程序格式错误。

我想知道为什么这个计划这么早就被拒绝了。在这种情况下，编译器应该很容易进行重载解析，因为两个函数具有相同的名称但不同的签名，因此不存在真正的歧义。是否有技术原因未完成此操作，或者是否有其他原因接受不正确的程序？有人知道这么早就决定拒绝这些计划背后的理由吗？

在C++中，不存在跨作用域的重载 http://www.stroustrup.com/bs_faq2.html#overloadderived– 派生类作用域也不例外此一般规则。请refer http://www.geeksforgeeks.org/does-overloading-work-with-inheritance/了解更多详情。 无论如何，您可以通过“using”关键字指定您想要使用 foo 的两个版本来改进您的示例。请参见下面的示例。

示例程序：

#include <iostream>
#include <string>

struct Aint 
{
     void foo(int){std::cout<<"\n Aint";}
};

struct Astring 
{
     void foo(std::string){std::cout<<"\n Astring";}
};

struct A: public Aint, public Astring {
    using Aint::foo;
    using Astring::foo;
    };

int main()
{
  std::string s;

  A a;
 a.foo(s);

  return 0; 
}
output:Astring