Multiple (diamond) inheritance compiles without "virtual", but doesn't with

Question

Given the following code (without virtual inheritance) :

class A
{
public:
    virtual void f() = 0;
};

class B : public A
{
 public:
    virtual void f() {}
};

class C : public A
{
 public:
    virtual void f() {}
};

class D : public B, public C
{

/* some code */
};


int main()
{
    D d;
    return 0;
}

the code compile.

On the other hand , here :

class A
{
public:
    virtual void f() = 0;
};

class B : virtual public A
{
    virtual void f() {}
};

class C : virtual public A
{
    virtual void f() {}
};

class D : public B, public C
{
    /* some code */
};


int main()
{
    D d;
    return 0;
}

The compiler presents a compilation error:

no unique final overrider for 'virtual void A::f()' in 'D' . 

Why is it different in the second code ?

Answer 1

Your first scenario hierarchy corresponds to:

    F()   F()
     A     A
     |     |
 F() B     C F()
      \   /
        D 

Where D is not abstract, because there are two A subobjects in an object of type D: One that is made concrete by B through the lattice of B, and another that is made concrete through the lattice of C.

Unless you try to invoke the function F() on object of D there will not be any ambiguity.

Your second scenario hierarchy corresponds to:

       F()  
        A
      /   \
 F() B     C F()
      \   /
        D  

In this scenario, the object D has a single Base class A sub object, and it must override and provide implementation of the pure virtual function in that subobject.

---

Herb Sutter's articles in Guru Of The Week(GOTW) are a nice read for Multiple Inheritance:

1. Multiple Inheritance Part I
2. Multiple Inheritance Part II
3. Multiple Inheritance Part III

Answer 2

With the virtual inheritance a D object has a single base-class A sub-object. This single sub-object can’t have two different implementations of a virtual function. In contrast, without virtual inheritance a D object has two distinct base-class A sub-objects, each with its own implementation of the function (which is OK until you try to call it on a D object, at which point you need to indicate which one you want).

Cheers & hth.