Question

I have diamond hierarchy of classes:

    A
  /   \
 B     C
  \   /
    D

To avoid two copies of A in D, we need to use virtual inheritance at B and C.

class A                     {  }; 
class B: virtual public A {};
class C: virtual public A   { }; 
class D: public B, public C { }; 

Question: Why does virtual inheritance needs to be performed at B and C, even though the ambiguity is at D? It would have been more intuitive if it is at D.

Why is this feature designed like this by standards committee?
What can we do if B and C classes are coming from 3rd party library ?

EDIT: My answer was to indicate B and C classes that they should not invoke A’s constructor whenever its derived object gets created, as it will be invoked by D.

Answer 1

I’m not sure of the exact reason they chose to design virtual inheritance this way, but I believe the reason has to do with object layout.

Suppose that C++ was designed in a way where to resolve the diamond problem, you would virtually inherit B and C in D rather than virtually inheriting A in B and C. Now, what would the object layout for B and C be? Well, if no one ever tries to virtually inherit from them, then they’d each have their own copy of A and could use the standard, optimized layout where B and C each have an A at their base. However, if someone does virtually inherit from either B or C, then the object layout would have to be different because the two would have to share their copy of A.

The problem with this is that when the compiler first sees B and C, it can’t know if anyone is going to be inheriting from them. Consequently, the compiler would have to fall back on the slower version of inheritance used in virtual inheritance rather than the more optimized version of inheritance that is turned on by default. This violates the C++ principle of “don’t pay what you don’t use for,” (the zero-overhead principle) where you only pay for language features you explicitly use.