Question

What happens in the following example?

struct B { };
struct D1 : B  { };
struct D2 : B  { };
int main()
{
    D1 d;
    D2 d2;
    B& x = d;
    x = d2;
}

I know the reference is not re-assigned. x still refers to d, but then how can you assign d2 to d?

Some more:

struct B
{
    B () { x = 0; }
    int x;
    virtual void foo () { cout << "B" << endl; }
};
struct D1 : B
{
    D1 () { x = 1; }
    virtual void foo () { cout << "D1" << endl; }
};
struct D2 : B
{
    D2 () { x = 2; }
    virtual void foo () { cout << "D2" << endl; }
};

int main()
{
D1 d;
D2 d2;
B& x = d;
x.foo();   //D1
               //x.x is 1 here
x = d2;
x.foo();   //also D1
               //but x.x is 2 here
}

It seems like x.x was updated, but the vftable was not… Why?

Answer 1

x refers to the B base class subobject of d. The assignment x = d2 slices the B base subobject from d2 and assigns its value to the subobject of d.

This is usually not done intentionally.

EDIT:

It seems like x.x was updated, but the vftable was not… Why?

That is what the assignment operator B::operator= does. Base classes in C++ are totally unaware that they are base classes. Also, the type of an object cannot ever be changed during its lifetime. The closest alternative is C++11’s std::move, which can transfer the old B object inside a D1 into a fresh D2 object. You would then destroy the old object.