Question

If I run the following code, I get different addresses printed. Why?

class Base1 {
    int x;
};

class Base2 {
    int y;
};

class Derived : public Base1, public Base2 {

};

union U {
    Base2* b;
    Derived* d;
    U(Base2* b2) : b(b) {}
};

int main()
{
    Derived* d = new Derived;

    cout << d << "\n";
    cout << U(d).d << "\n";

    return 0;
}

Even more fun is if you repeatedly go in and out of the union the address keeps incrementing by 4, like this

int main()
{
    Derived* d = new Derived;

    cout << d << "\n";
    d = U(d).d;
    cout << d << "\n";
    d = U(d).d;
    cout << d << "\n";

    return 0;
}

If the union is modified like this, then the problem goes away

union U {
    void* v;
    Base2* b;
    Derived* d;
    U(void* v) : v(v) {}
};

Also, if either base class is made empty, the problem goes away.
Is this a compiler bug? I want it to leave my pointers the hell alone.

Answer 1

If I run the following code, I get different addresses printed. Why?

Because the Base2 sub-object of the Derived object isn’t at the start of the Derived object. So the addresses are different. When the compiler performs an implicit cast from a Derived* to a Base2*, it needs to adjust the address.

Given the definitions of the Base1 and Base2 classes, both sub-objects of the Derived class cannot possibly be at the starting address of a Derived object – there’s no room at that address for both sub-objects.

Say you had this code:

Derived* d = new Derived;

Base1* pb1 = d;
Base2* pb2 = d;

How would it be possible for pb1 and pb2 to point to the same address? pb1 has to point to a Base1::x item, and pb2 has to point to a Base2::y item (and those items have to be distinct).

Even more fun is if you repeatedly go in and out of the union the address keeps incrementing by 4

Because you’re reading from the union’s d member after writing the b member, which is undefined behavior (you’re essentially performing something like a reinterpret_cast<Derived*>() on a Base2*).

I want it to leave my pointers the hell alone.

Not if you want a Base2* pointer. Multiple inheritance makes things more complex – that’s why many people suggest avoiding it unless absolutely necessary.