C++: Unexpected size of class object in multiple inheritance

Question

I've noticed strange behaviour in multiple inheritance. Let's look at the following example:

#include <iostream>
using namespace std;

struct A {};
struct B : public A { double x; };
struct C : public A, public B {};

int main() {
    cout << "Size of double: " << sizeof(double) << endl;
    cout << sizeof(A) << ", " << sizeof(B) << ", " << sizeof(C) << endl; // gives 1, 8, 16
}

Size of A type is 1 (weird, but acceptable), size of B type is equal to 8 (same as double type, which is expected), but size of C type... is equal to 16. Which is even more weird, when I tried to find unexpected variable I couldn't identify it.

struct D { double a, b; };

C c;
auto &d = reinterpret_cast<D&> (c);
d.a = 1;
d.b = 2;

cout << c.x << endl; //gives 2
cout << c.B::x << endl; //gives 2
cout << c.C::x << endl; //gives... 2

cout << d.a << ", " << d.b << endl; //gives 1, 2

I've got this way a totally unexpected field of data in an object and I can't access to it in a normal way. Is there some way to explain it? Is it expected behaviour from C++ compiler?

BTW, code was written and compiled in Visual Studio 2015, 64x, but when I compiled the first part on g++ (Ubuntu), result was the same - 1, 8, 16.

Ah, to specify my problem - I would like to store large number of data specified as inherited type, that's why I am concerned about useless reserved bytes. If anyone have a solution I'll be glad to hear - even if it's some #define or compiling option.

Answer 1

Yes, C++ allows the size of an empty base subobject to be 0 bytes, this is call empty base optimization. But every object has to have a unique address, so sizeof an empty class instantiation on it's own is 1 byte.

Answer 2

There isn't really much of a surprise here:

1. You got two A subobjects in C: the first one immediately inherited by C and the second one indirectly inherited via B. These two subobjects need to have different addresses.
2. The double in B wants to be aligned to a suitable address, i.e., there will be padding if necessary to make sure it is at an 8 byte boundary (typically; there is no mandate for padding or the size of any such padding).
3. To create an array of objects (which defines the size reported by sizeof()) the object will be padded independent on which size the immediate A subobject resides.

Note that the problem exists entirely because you have two empty bases of the same type! If you had another base which is also empty it could legitimately share the address of A and the entire object size would just be 8.