Difference between class and struct with regards to padding and inheritance

Question

All of the below will be done on GCC 9.1 using Compiler Explorer, in x86-64, using -O3.

I have this code:

struct Base {
    Base() {}
    double foo;
    int bar;
};

struct Derived : public Base {
    int baz;
};

int main(int argc, char** argv)
{
    return sizeof(Derived);
}

https://godbolt.org/z/OjSCZB

It correctly returns 16, as I would expect, 8 bytes for foo, and 4 bytes for bar and 4 bytes for baz. This works only because Derived inherits from Base and so it does not have to pad after bar due to Derived being a single type containing both Base and Derived elements.

I have two questions, as below:

First question

If I remove the explicit constructor of Base() {}, it starts returning 24, instead of 16. i.e. it adds padding after bar and baz.

https://godbolt.org/z/0gaN5h

I can't explain why having an explicit default constructor is any different to having an implicit default constructor.

Second question

If I then change struct to class for Base, it changes back to returning 16. I can not explain this either. Why would the access modifiers change the size of the structure?

https://godbolt.org/z/SCYKwL

Half a dupe of https://stackoverflow.com/q/47914612/560648. I don't know why changing the keyword introducing the base would make a difference though (given that there's no member re-ordering going on anyway so differing member access levels oughtn't come into it) — Lightness Races in Orbit, Jul 19 '19 at 14:08
Ah thanks! That answer the first question, but not the second — Salgar, Jul 19 '19 at 14:10
Re: "It correctly returns 16, as I would expect" -- by definition, the result of `sizeof` is **correct**, regardless of what you expect. — Pete Becker, Jul 19 '19 at 14:11
@LightnessRacesinOrbit not a bug. Aggregates can't have private members — NathanOliver, Jul 19 '19 at 14:13
it seems that padding happens when you mix private/public fields — Andrew Kashpur, Jul 19 '19 at 14:13

NathanOliver · Accepted Answer · 2019-07-19T14:28:20.450

This all boils down to whether your type is an aggregate or not. With

struct Base {
    Base() {}
    double foo;
    int bar;
};

struct Derived : public Base {
    int baz;
};

Base is not an aggregate because of the constructor. When you remove the constructor, you make Base an aggregate which, per Adding a default constructor to a base class changes sizeof() a derived type, means gcc won't "optimize" for space and the derived object won't use the base's tail padding.

When you change the code to

class Base {
    double foo;
    int bar;
};

struct Derived : public Base {
    int baz;
};

foo and bar are now private (becauses classes have private accessibility by default) which again means Base is no longer an aggregate as aggregates are not allowed to have private members. This means we are back to how the first case works.

Turtlefight · Answer 2 · 2019-07-19T14:33:53.657

With your Base class you will get 4 bytes of tail padding, and the same with the Derived class, that's why it should normally be 24 bytes total for the size of Derived.

It becomes 16 bytes, because your compiler is able to do tail padding reuse.

However tail padding reuse is problematic with POD types (all members public, defaulted constructor, etc...), because it breaks common assumptions a programmer would make. (So basically any sane compiler won't do tail padding reuse for pod types)

Let's pretend compilers would use the tail padding reuse for POD types:

struct Base {
    double foo;
    int bar;
};

struct Derived : Base {
    int baz;
};

int main(int argc, char** argv)
{
    // if your compiler would reuse the tail padding then the sizes would be:
    // sizeof(Base) == 16
    // sizeof(Derived) == 16

    Derived d;
    d.baz = 12;
    // trying to zero *only* the members of the base class,
    // but this would zero also baz from derived, not very intuitive
    memset((Base*)&d, 0, sizeof(Base));

    printf("%d", d.baz); // d.baz would now be 0!
}

When adding an explicit constructor to the Base class, or by changing the struct keywords to class, the Derived class doesn't satisfy the POD definition anymore and therefore tail padding reuse doesn't happen.

Difference between class and struct with regards to padding and inheritance

2 Answers2

Linked