Why size of derived class having virtual inheritance is coming unexpected?

Question

As the size of empty class is 1 byte but when this empty class is virtually inherited that (on gcc compilers) the answer to sizeof(derived1) is coming out to be 8 byte...,how come this is happening as sizeof(derived1) must be sizeof(char)+sizeof(virtual pointer), which is 1+4..i.e 5 byte.,so, from where this extra 3 bytes is coming...???

#include <iostream>
using namespace std;

class Empty
{};

class Derived1 : virtual public Empty<br>
{
    char c;
};

int main()
{
    cout << "sizeof(Empty) " << sizeof(Empty) << endl;
    cout << "sizeof(Derived1) " << sizeof(Derived1) << endl;
    return 0;
}

Answer 1

It's all unspecified as far as the C++ standard is concerned, but typically virtual inheritance adds a pointer or two, which in turn imposes additional alignment constraints; the size of a class with virtual inheritance or virtual functions will almost certainly have to be a multiple of the size of a pointer (4 or 8 on most systems).

Answer 2

The problem is in structure memory alignment. For more details check this atricle: http://en.wikipedia.org/wiki/Data_structure_alignment As you can see the memory padding depends on your platform.

Explanation:

Let's try to debug memory used for your class. As we know variables are not virtuals. That means there is no record of vintrual table to determine which variable to use. So compiler does not need to create virtual functions table unless you have no virtual functions. On my machine virtual functions table pointer member is called __vfptr. On debug you will not be able to find the member with this name unless you add an virtual function. That means you should remove virtual functions pointer size from you calculations. Try to run following code and read the comments for details:

struct Empty
{

};

struct VirtualNotEmpty: public virtual Empty
{
    char c;
};

struct VirtualNotEmptyEx: public virtual Empty
{
    char c1;
    char c2;
    char c3;
    char c4;
};

struct TrueVirtualNotEmpty: public virtual Empty
{
    virtual void f() {}
    char c;
};

void inspect_vne()
{
    VirtualNotEmpty vne;

    char* start_of_struct = (char*)(&vne);
    char* end_of_struct = (char*)(&vne);
    end_of_struct += sizeof(vne);
    char* start_of_var = (char*)(&(vne.c));

    printf("sizeof(VirtualNotEmpty): %d\n", sizeof(vne));                    // 8 bytes
    printf("Address of struct %p\n", start_of_struct);
    printf("Lenght of struct %d\n", (int)(end_of_struct - start_of_struct));    // same as sizeof
    printf("Address of var c %p\n", start_of_var);
    printf("Diff from start: %d\n", (int)(start_of_var - start_of_struct));        // 4 bytes: 1 byte for struct and 3 bytes for padding
    printf("Diff from end: %d\n", (int)(end_of_struct - start_of_var));            // 4 bytes:    1 byte for struct and 3 bytes for padding

    // [st][pd][pd][pd] [ch][pd][pd][pd]
    // st -- struct vt -- virtual table, pd -- padding byte ch -- char member variable
}

void inspect_tvne()
{
    TrueVirtualNotEmpty vne;

    char* start_of_struct = (char*)(&vne);
    char* end_of_struct = (char*)(&vne);
    end_of_struct += sizeof(vne);
    char* start_of_var = (char*)(&(vne.c));

    printf("sizeof(TrueVirtualNotEmpty): %d\n", sizeof(vne));                //    12
    printf("Address of struct %p\n", start_of_struct);
    printf("Lenght of struct %d\n", (int)(end_of_struct - start_of_struct)); // same as sizeof
    printf("Address of var c %p\n", start_of_var);
    printf("Diff from start: %d\n", (int)(start_of_var - start_of_struct)); // 8 bytes: 1 byte for struct + 3 bytes of struct padding + 4 bytes o vptr
    printf("Diff from end: %d\n", (int)(end_of_struct - start_of_var));        // 4 bytes: 1 byte for member variable + 3 bytes for padding

    // [st][pd][pd][pd] [vt][vt][vt][vt] [ch][pd][pd][pd]
    // st -- struct vt -- virtual table, pd -- padding byte ch -- char member variable
    // member variable TrueVirtualNotEmpty::c can't be packed at first byte, because of order of dectaled members __vptr is declared bevore
    // TrueVirtualNotEmpty::c
}

int main(int, char**)
{
    printf("Size of pointer %d", sizeof(int*)); // 4 on my machine    
    inspect_vne();
    inspect_tvne();
    printf("Size of VirtualNotEmptyEx %d\n", sizeof(VirtualNotEmptyEx));    // there is no need to create padding at
                                                                            // end for c1-c4 chars because there is space to pack them
    return 0;
}

As you can see size of struct on my machine should be dividable by 4.