C++ inheritance - ambiguous Function

Question

I've got an Inheritance problem: Let's say I've got

class Time{
protected:
void foo();
};

and also

class Base: private Time{
void foo1(){ foo(); }
};

class Child: public Base, private Time{
void foo2(){ foo(); }// here my compiler says that foo is ambiguous
};

why is foo() ambiguous, if the inheritance of Time in Base is private?

PS. Just&only for those who need to see the full code, here is the GitHub Project: https://github.com/huntekah/Interior_decorator-OpenGL_Project/blob/master/Grafika-OpenGL/Interior_decorator/Display.cpp#L133 class Time( utilities directory ) is inherited by ControlObjects and ControlCamera, both of which are the base for Controls. Display inherits Controls , and additionally Time. commented line shows a place where SetDeltaTime() is ambiguous;

Because both `Base` and `Time` have a member function named `foo` and the compiler doesn't know which one you are trying to invoke. There's a dupe of this out there somewhere. — Captain Obvlious, Sep 07 '16 at 21:03
See http://stackoverflow.com/questions/9975291/ambiguous-when-two-superclasses-have-a-member-function-with-the-same-name-but, http://stackoverflow.com/questions/18158094/fixing-c-multiple-inheritance-ambiguous-call, and http://stackoverflow.com/questions/6845854/c-multiple-inheritance-function-call-ambiguity just to start. — Captain Obvlious, Sep 07 '16 at 21:06
You may find the answers here (including but not limited to mine!) helpful: http://stackoverflow.com/q/39042240/1858225 In short, visibility is *never* part of function-lookup and overload resolution; the compiler picks the best match *before* checking whether the function is visible from the calling context. — Kyle Strand, Sep 07 '16 at 21:07
yaay, knowledge :3 thank you! btw: Child::Time::foo() is not ambiguous — Yurkee, Sep 07 '16 at 21:07
`foo()` is private. You cannot call from any derivative class. — BiagioF, Sep 07 '16 at 21:19

score 1 · Answer 1 · answered Sep 08 '16 at 00:53

there's another error in your code: class base inherits privately from class Time and class Child inherits again privately from class time!!!

the law of inheritance:

class Time
{};

class Base : private Time
{};

class Child : public Base, private Time
{};

Base has a copy of class Time because it inherits from it.

child has a copy of class Base because it inherits from it.

*** Child has a copy of class Time because its parents (Base) has this copy.

if Child tries to inherit explicitly from class Time will issue a compile-time-error: error C2584: 'Child' : direct base 'Time' is inaccessible; already a base of 'Base'

Christophe · Answer 2 · 2016-09-07T22:15:26.013

Preliminary remarks

Your code snippet doesn't compile for another reason: Base has no access to Time's foo() as it is a private member. So the foo1() causes an error, before you have the reported ambiguity.

If you change Time to make its member protected, then you can reproduce your error exactly as you describe:

class Time{
protected:
    void foo();
};

What's wrong here ?

Base privately inherits Time, so that it's members are not expected to be visible to the outside world.

But what could be true for the external world is not true for derived classes. The name lookup rules in the case of derivation say that first the name is looked up in the class hierarchy, then overloading is applied, than only is access control carried out:

10.2/1 Member name lookup determines the meaning of a name (id-expression) in a class scope. Name lookup can result in an ambiguity, in which case the program is ill-formed. For an id-expression, name lookup begins in the class scope of this; for a qualified-id, name lookup begins in the scope of the nested-name-specifier. Name lookup takes place before access control.
10.2/8 If the name of an overloaded function is unambiguously found, overloading resolution also takes place before access control. Ambiguities can often be resolved by qualifying a name with its class name.

As you use multiple inheritance:

Time     
  :
  :
Base  Time 
    \  :
     \ : 
    Child

So you inherit twice a foo(), once via private inheritance and onve via public. This ambiguity makes the name foo in foo2() ambiguous according to the standard, and before access is verified, making your code invalid.

Note that Child sees 2 foo() but ironically can't use none of them: both come via private inherited. So even if you'd resolve the ambiguity, you'd get another error message about accessibility.

C++ inheritance - ambiguous Function

2 Answers2