Question

I would like some help explaining this phenomenom:

#include <iostream>
using namespace std;

class A
{
public:
    void m() {cout<<"A::m "<<this<<endl;};
};

class B1:  public A
{
public:
    void m() {cout<<"B::m "<<this<<endl;};
};

class B2:  public A ,public B1
{
};

class D : public B2
{};

int main()
{
    B2 b;
    D d;
    A* a = &b; // Row 27
    //error: a = &d;  Base class 'A' is ambiguous // Row 28
    return 0;
}

Why does the code in Row27 work but the code in Row28 doesnt?
Thank in advance!

Note: I am well aware of virtual inheritance, I just want to know what is the difference between Row27 and Row28 – why one throw a compilation error when the other not?

Answer 1

Because you are using non-virtual inheritance to derive from A, which indirectly creates two sub-objects of type A in every object of type D. The compiler cannot disambiguate which sub-object you refer to when doing the pointer-to-derived to pointer-to-base conversion, and issues an error.

In order to have only one sub-object of type A generated for objects of type D, you have to make inheritance from A virtual along the inheritance paths which make D derive from A:

class B1:  virtual public A
{
    // ...
};

class B2:  virtual public A, public B1
{
};

EDIT:

I tried to compile your example on Visual Studio 2010 SP1, which gives me a warning about the definition of B2:

class B2: public A, public B1
{
};

1>sotest.cpp(18): warning C4584: 'B2' : base-class 'A' is already a base-class of 'B1'
1>          sotest.cpp(6) : see declaration of 'A'
1>          sotest.cpp(11) : see declaration of 'B1'

In other words, for some reason VC10 seems to consider the inheritance from A redundant and ignores it. This is why the assignment A* a = &b; compiles: class B2 actually inherits from A only once (through B1). The same is not true of D, because VC10 has probably no redundant inheritance to ignore, and D effectively inherits from A twice (through B1 and through B2).

I ignore the reasons why VC10 behaves this way, and I do not know if there is a compiler option to suppress this behavior. Remarkably, both GCC 4.7.2 and Clang 3.2 refuse to compile the assignment A* a = &b;.