C++ sizeof operator before and after extending

Question

I am now testing the result of C++ sizeof operator:

class S{};
class A:public S{
    virtual void fun()=0;
};
class B{};
class C : public B,public A {};

int main(){
     cout<<sizeof(A)<<endl;// result is 4
     cout<<sizeof(C)<<endl;// result is 8
}

But if I remove the extend of class S:

class A{
    virtual void fun()=0;
};
class B{};
class C : public B,public A{};

int main(){
    cout<<sizeof(A)<<endl;// result is 4
    cout<<sizeof(C)<<endl;// result is 4
}

Can anyone explain the different of the output of sizeof(C) in those two examples? Class S is just an empty class (I know, sizeof(S) == 1), so why does it make a difference whether or not A has a base class? Especially since it doesn't make any difference to sizeof(A), only to sizeof(C)?

Compiler and version, please. clang++ does not behave this way: http://coliru.stacked-crooked.com/a/f7894a53eb6018e1 — dyp, Oct 08 '14 at 13:21
http://www.cprogramming.com/tutorial/size_of_class_object.html — Ashalynd, Oct 08 '14 at 13:30
It seems to be VS, at least VS2013 for Win32 target is doing this. Also for x64 the output is `8 16` in the first case and `8 8` in the second. — Anton Savin, Oct 08 '14 at 13:42
This smells like an alignment issue. Note that adding an int or even a char to S increases the size of A by 4, but does not increase the size of C — Gonen I, Oct 08 '14 at 13:43
Also weird, add a different pure virtual function to S as well, and the sizes go back to 4,4. — Gonen I, Oct 08 '14 at 13:54
@AntonSavin heh, my clang 3.5 on x64-darwin (OS X) spits out `8 8` for *both*. — WhozCraig, Oct 08 '14 at 14:15
Perhaps a duplicate of http://stackoverflow.com/questions/12701469/why-empty-base-class-optimization-is-not-working — Bill Lynch, Oct 08 '14 at 14:17
@AntonSavin I certainly expect that as well. Love VS (always wanna be different, these kids!). — WhozCraig, Oct 08 '14 at 14:22

score 3 · Answer 1 · answered Oct 08 '14 at 14:13

3

It seems that VS can't handle properly a situation when there are more than one empty base classes. In your first example theres is one empty base class, and in the second there are two. For example on my box this code compiled on VS2013:

#include <iostream>

class B1 {};
class B2 {};
class B3 {};
class B4 {};
class B5 {};
class B6 {};

class C1 : B1 {};
class C2 : B1, B2 {};
class C3 : B1, B2, B3 {};
class C4 : B1, B2, B3, B4 {};
class C5 : B1, B2, B3, B4, B5 {};
class C6 : B1, B2, B3, B4, B5, B6 {};

int main() {
    std::cout << sizeof(C1) << ' ' << sizeof(C2) << ' ' << sizeof(C3) << ' '
        << sizeof(C4) << ' ' << sizeof(C5) << ' ' << sizeof(C6) << std::endl;
}

outputs

1 1 2 3 4 5

While both clang and gcc output 1 1 1 1 1 1.

But this behavior is still standard compliant, because the standard doesn't oblige the implementation to optimize empty base classes away.

answered Oct 08 '14 at 14:13

Anton Savin

40,838
8
54
90

I don't have VS here and I can't test, but what happens if you add `#pragma pack` into the code? – Jepessen Oct 08 '14 at 14:30
1

Now that I see this answer, it reminds me that the subject has come up before. http://stackoverflow.com/questions/6119927/empty-base-optimisation-msvc http://stackoverflow.com/questions/12701469/why-empty-base-class-optimization-is-not-working http://stackoverflow.com/questions/17620050/padding-with-multiple-derivation-of-empty-classes-only-under-windows http://stackoverflow.com/questions/24722070/how-to-optimize-objects-memory-size-while-using-multiple-inheritance-with-visua – Mark Ransom Oct 08 '14 at 15:35
@Jepessen with `#pragma pack(push, 1)` the OP's code yields `4 5` and `4 4` respectively for Win32, `8 9` and `8 8` for x64. My code yields the same `1 1 2 3 4 5` – Anton Savin Oct 09 '14 at 06:42

Gonen I · Answer 2 · 2014-10-08T15:27:09.503

It seems that in Multiple Inheritance, Visual Studio reserves at least 1 byte for every empty class.

With default alignment of 4 bytes, this leads to class C being 8 bytes.

But this may serve a purpose.

With multiple inheritance, C class looks like this:

B Part

S Part

A Part

C Part

The reservation allows getting different identities for the parts as follows:

C c1;
printf("address of S part %ld\n",static_cast<S*> (&c1));  // prints 4651208
printf("address of B part %ld\n",static_cast<B*> (&c1));  // prints 4651209 with one byte alignment

C++ sizeof operator before and after extending

2 Answers2