Pourquoi des fonctions à héritage multiple portant le même nom mais des signatures différentes ne sont-elles pas traitées comme des fonctions surchargées?

Question

L'extrait suivant génère une erreur "d'appel ambigu à toto" lors de la compilation, et j'aimerais savoir s'il est possible de résoudre ce problème sans qualifier complètement l'appel à toto:

 #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;
}
 

Donc, la question est comme le titre l'indique. Des idées? Je veux dire, les travaux suivants fonctionnent parfaitement:

 #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;
}
 

Answer 1

Recherche d'un membre règles sont définies dans la Section 10.2/2

Les étapes suivantes de définir le résultat de recherche d'un nom dans un contexte de classe, C. Tout d'abord, chaque déclaration pour que le nom de la classe et dans chacune de ses de la classe de base des sous-objets est considéré comme. Un nom de membre f dans un sous-objet d' B se cache le nom d'un membre f dans un sous-objet d' A si A est une classe de base sous-objet de B. Toutes les déclarations qui sont cachées sont éliminés de la considération. Chacune de ces déclarations, qui a été introduite par un aide-déclaration est considéré être de chaque sous-objet de C qui est du type de contenant la déclaration désigné par l'aide-déclaration. Si l'ensemble des déclarations ne sont pas tous des sous-objets de même type, ou l'ensemble a un membre non statique et comprend des membres provenant de différents sous-objets, il existe une ambiguïté et le programme est mal formé. Sinon, cet ensemble est le résultat de la recherche.

class A {
public:
  int f(int);

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

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

Ainsi, vous pouvez utiliser l' using des déclarations en A::f et B::f pour résoudre cette ambiguïté

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

};

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

Le deuxième code fonctionne parfaitement, car void foo(float) est à l'intérieur C du champ d'application. En fait d.foo(5); des appels void foo(float) et pas l' int version.

Answer 2

ça va fonctionner pour vous?

 struct Derived : public Base1, public Base2{
   using Base2::foo;}