Question

I have the following code sample:

class A
{
public:
    A(int a):AA(a) {};

    int AA;

    virtual int Test() 
    {
        return AA;
    };
};

class B
{
public:
    B(int b):BB(b) {};

    int BB;

    virtual int Test() 
    {
        return BB;
    };
};

class C:public A, public B
{
public:
    C(int a, int b, int c) :A(a),B(b),CC(c) {};

    int CC;
};

int main()
{
    A *a = new C(1,2,3);
    B *b = new C(1,2,3);
    C *c = new C(1,2,3);


    int x = a->Test() ; // this is 1
    int y = b->Test() ; // this is 2
//  int z = c->Test() ; // this does not compile

    return 0;
}

I was expecting the calls to a->Test() and b->Test() to be ambiguous too as the object a is a C and therefore inherits from A and B both of whom have identical Test() functions. However, they both call the implementation which corresponds to the delcared type rather than the type that the object actually is.

Can anyone explain why these calls are not ambiguous?
Does C++ always behave this way?

Answer 1

In fact,a C instance is both a full A instance and a full B instance (so holds a copy of A methods & B methods)

Since a is a A* , the compiler will use the A virtual table copy that is inside of the C instance
Since b is a B* , the compiler will use the B virtual table copy that is inside of the C
instance

you cannot use C* since the compiler will not now which Test() method of A or B you want to call (since the C class holds both A::Test & B::Test symbols)

if you implement a C::Test() method, then it will be called both instead of A::Test() & B::Test() since method is virtual for both A & B.