Question

while trying to analyse in greater depth inheritance mechanism of C++ I stumbled upon the following example:

#include<iostream>

using namespace std;

class Base {
public:
    virtual void f(){
    cout << "Base.f" << endl; 
    }
};

class Left : public Base { //NOT VIRTUAL!!!
public:
void g(){ 
        f();
    }     
};

class Right : public Base{
public:
    virtual void f(){
    cout << "Right.f" << endl; 
    }
};

class Bottom : public Left, public Right{
public:
    Bottom(int arg){ }
    //void f() { }
};

int main(int argc,char **argv)
{
    Bottom* b = new Bottom(23);
    b->g();
}

It is clear that calling

b->f()

is ambiguous, so there is no unique method f() on object Bottom. Now, calling

b->g()

works fine and prints

Base.f

Well, as far as I see this:

1. static type is Bottom, so we call its g() method, as it is non-virtual
2. g() method is inherited from Left, so we call this inherited method
3. Now, g() in Left tries to call virtual method f(). According to C++ sepcification, we call f() method of a dynamic type of our pointer (which is Bottom)

BUT Bottom does not have method f()… at least not a unique one. Why does this program executes Left::Base::f() rather than Right::Base::f() or why does it simply not states that call to f() is ambiguous from Bottom?

Answer 1

The short answer is that (as you noted), Bottom does not have method f(), so there is no need in trying to call it.

Bottom contains the two subobjects Left and Right. Each of them inherits from Base, so Bottom contains the member functions Left::f() and Right::f(), but no Bottom::f(). Since Bottom does not override Left::f() (using Right::f() for example), Base::f() is the unique final overrider in Left::g().

cf. the example in 10.3.9 from the C++03 standard.