为什么具有相同名称但不同签名的多继承函数不会被视为重载函数？

问题描述

以下代码段在编译期间产生了一个对foo的歧义调用错误，我想知道是否有任何方式围绕这个问题，没有完全限定调用foo：

The following snippet produces an "ambigious call to foo" error during compilation, and I'd like to know if there is any way around this problem without fully qualifying the call to foo:

#include <iostream>

struct Base1{
    void foo(int){
    }
};

struct Base2{
    void foo(float){
    }
};

struct Derived : public Base1, public Base2{
};

int main(){
    Derived d;
    d.foo(5);

    std::cin.get();
    return 0;
}

所以，问题是标题说的。想法？我的意思是，以下工作完美无瑕：

So, question is as the title says. Ideas? I mean, the following works flawlessly:

#include <iostream>

struct Base{
    void foo(int){
    }
};

struct Derived : public Base{
    void foo(float){
    }
};

int main(){
    Derived d;
    d.foo(5);

    std::cin.get();
    return 0;
}

推荐答案

第10.2 / 2节

class A {
public:
  int f(int);

};
class B {
public:
   int f();

};
class C : public A, public B {};
int main()
{
     C c;
     c.f(); // ambiguous
}

因此，您可以使用 using 声明 A :: f 和 B :: f

So you can use the using declarations A::f and B::f to resolve that ambiguity

class C : public A, public B {
     using A::f;
     using B::f;

};

int main()
{
     C c;
     c.f(); // fine
}

第二个代码无缺陷地工作，因为 void foo（float）在C的范围内。实际上 d.foo（5）; 调用 void foo（float）而不是 int 版本。

The second code works flawlessly because void foo(float) is inside C's scope. Actually d.foo(5); calls void foo(float) and not the int version.

这篇关于为什么具有相同名称但不同签名的多继承函数不会被视为重载函数？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！