This article describes a design choice in the C++ ABI of the Visual Studio compiler that I believe should be considered a bug. I propose a trivial workaround at the end.

TL;DR — if the topmost polymorphic class in a hierarchy has members with alignment requirement N where N > sizeof(void *) , the Visual Studio compiler may add up to N bytes of useless padding to your objects.

Update: be sure to read the explanation by Jan Gray, who designed the relevant part of the MS C++ ABI some 22 years ago, in the comments section below.

My colleague ​Benlitz first hit the problem when trying to squeeze memory out of some of ​our game’s most often instantiated classes. I think it is best illustrated with the following minimal example:

class Foo { virtual void Hello() {} float f; /* 4 bytes */ };

class Bar { virtual void Hello() {} float f; /* 4 bytes */ double d; /* 8 bytes */ };

This is the size of Foo and Bar on various 32-bit platforms:

Platform sizeof(Foo) sizeof(Bar) Madness? Linux x86 (gcc) 8 16 no Linux ARMv9 (gcc) 8 16 no Win32 (gcc) 8 16 no Win32 (Visual Studio 2010) 8 24 yes Xbox 360 (Visual Studio 2010) 8 24 yes PlayStation 3 (gcc) 8 16 no PlayStation 3 (SNC) 8 16 no Mac OS X x86 (gcc) 8 16 no

There is no trick. This is by design. The Visual Studio compiler is literally stealing 8 bytes from us!

What the fuck is happening?

This is the memory layout of Foo on all observed platforms:

The vfptr field is a special pointer to the vtable. The vtable is probably the most widespread compiler-specific way to implement virtual methods. Since all the platforms studied here are 32-bit, this pointer requires 4 bytes. A float requires 4 bytes, too. The total size of the class is therefore 8 bytes.

This is the memory layout of Bar on eg. Linux using GCC:

The double type has an alignment requirement of 8 bytes, which makes it fit perfectly at byte offset 8.

And finally, this is the memory layout of Bar on Win32 using Visual Studio 2010:

This is madness! The requirement for the class to be 8-byte aligned causes the first element of the class to be 8-byte aligned, too! I demand a rational explanation for this design choice.

The problem is that the compiler decides to add the vtable pointer after it has aligned the class data, resulting in excessive realignment.

Compilers affected

The Visual Studio compilers for Win32, x64 and Xbox 360 all appear to create spurious padding in classes.

Though this article focuses on 32-bit platforms for the sake of simplicity, 64-bit Windows is affected, too.

The problem becomes even worse with larger alignment requirements, for instance with SSE3 or AltiVec types that require 16-byte storage alignment such as _FP128 :

class Quux { virtual void Hello() {} float f; /* 4 bytes */ _FP128 dd; /* 16 bytes */ };

This is the GCC memory layout on both 32-bit and 64-bit platforms:

The padding there is perfectly normal and expected, because of the alignment requirements for dd .

But this is how Visual Studio decides to lay it out:

That is 16 lost bytes, both on 32-bit and 64-bit versions of Windows.

Workaround

There is fortunately a workaround if you want to get rid of the useless padding. It is so trivial that it actually makes me angry that the problem exists in the first place.

This will get you your bytes back:

class EmptyBase { protected: virtual ~EmptyBase() {} }; class Bar : public EmptyBase { virtual void Hello() {} float f; /* 4 bytes */ double d; /* 8 bytes */ };

And this is the size of Bar on the same 32-bit platforms:

Platform sizeof(Bar) Linux x86 (gcc) 16 Linux ARMv9 (gcc) 16 Win32 (gcc) 16 Win32 (Visual Studio 2010) 16 Xbox 360 (Visual Studio 2010) 16 PlayStation 3 (gcc) 16 PlayStation 3 (SNC) 16 Mac OS X x86 (gcc) 16

Phew. Sanity restored.

The compiler is a lot less confused now: it no longer has to create space for a vfptr in Bar since it is technically already part of EmptyBase .

Conclusion

Lessons learned:

The pointer to the vtable isn’t just like any other pointer.

Various C++ ABIs have different stances on padding and alignment.

Inheriting from an empty abstract class can make your objects smaller on Windows and Xbox 360!

Design decisions can haunt you for decades!

The workaround is so simple that it sounds like a good idea to always use it, preemptively.