Overloaded Functions with Multiple Inheritance

In C , function overloading allows multiple functions with the same name to be defined within a single scope, provided they have different parameter lists. However, this behavior does not extend to multiple-inherited functions with the same name but different signatures. This raises the question: why don't such functions get treated as overloaded?

According to Section 10.2/2 of the C Standard, member lookup rules dictate that hidden declarations are eliminated from consideration during name lookup. When multiple base classes define functions with the same name but different parameters, these functions may be hidden from each other. Therefore, if the resulting set of declarations is not from sub-objects of the same type, or includes a nonstatic member and members from different sub-objects, an ambiguity arises and the program is considered ill-formed.

For example:

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

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

class C : public A, public B {};

In this case, f is ambiguous because it is defined in two different base classes (A and B). Therefore, the following call to f from the C class is incorrect:

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

To resolve this ambiguity, you can use the using declaration to specify which base class implements the f function. For example:

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

With this modification, c.f() now explicitly calls f from class A, resolving the ambiguity.

In contrast, the second code example you provided works because foo(float) is defined within the scope of the Derived class, and is not inherited from multiple base classes. Therefore, d.foo(5) calls the foo(float) function directly, without any ambiguity.