为什么编译器会抱怨对齐？

Question

I'd like to understand more about alignment. Why does the Microsoft compiler (Visual Studio 2012 Express) complain about the alignment for the following snippet of code?

__declspec(align(16)) class Foo
{
public:
    virtual ~Foo() {}
    virtual void bar() = 0;
};

This is the warning the compiler presents to me:

warning C4324: 'Foo' : structure was padded due to __declspec(align())

It does not even matter whether or not the class has any virtual methods. Even for an empty class the compiler complains with the same warning message. How is an empty class aligned? How does the compiler pad this class?

Answer 1

A warning does not necessarily mean you've done something wrong, but tells you that you might not have intended this behaviour. Note that a compiler is allowed to warn about anything the developers considered worth warning about. In principle, you could also be warned about compiling on Friday the 13th.

In this specific case the assumption probably is that when you specify alignment, you don't want to make the class bigger. Therefore if the class gets bigger due to the alignment requirement you gave, it's not unlikely that you made a mistake.

Of course that leaves the question why the alignment requirement makes the class bigger. Now we are back in standards land (although the __declspec itself is a Microsoft extension and not standard). The C++ standard requires that in arrays, the objects follow each other without any space in between. Therefore if your objects must be aligned to 16-byte boundaries, the object must have a size which is a multiple of 16. If the size of the members (both explicit and implicit) doesn't give the necessary size, the compiler has to add unused bytes to the object. These bytes are called padding. Note that this padding is present even in objects which are not members of arrays.

Now your class only contains an implicit virtual pointer (because it contains virtual functions) which, depending on the architecture, probably is either 4 or 8 bytes large. Since you've requested 16 byte alignment, the compiler has to add 12 or 8 bytes of padding to get the size to a multiple of 16, which it would not have had to add without that manual alignment specification. And this is what the compiler warns about.

Answer 2

In x86 Foo needs 4 bytes, so a 12-byte pad is needed. In x64 Foo needs 8 bytes, so a 8-byte pad is needed.

Answer 3

What this warning says is that the size of the class (as returned by sizeof ) has changed (increased) as a result of using the __declspec(align()) . That may break things, thus the warning.

An empty class has a size, of course, and must be greater than 0, so it is at least 1.

Normally the size doesn't change with the alignment, but in your case it does, because you specified an alignment that is bigger than the unpadded size of the class. And remember that in C the alignment of a type cannot be smaller than its size, actually the size must be a multiple of the alignment, so the size is increased to match the alignment.

Why must the size be a multiple of the alignment? Well, imagine an array of this type: consecutive elements are required to be separated by exactly sizeof(T) , but each object must be in a memory address multiple of the alignment. The only solution to this equation is that sizeof(T) must be a (non-null) multiple of the alignment.

Answer 4

When you increase the alignment of your structure using __declspec(align()) or alignas() , it not only causes your structure to be aligned stricter, but may have to pad your structure at the end, according to this rule :

The size of a structure is the smallest multiple of its alignment greater than or equal to the offset of the end of its last member.

In other words, if you increase alignment of a structure to say, 16, you better make sure the size of your struct is also a multiple of 16, or you risk having your struct changing in size due to padding, which may cause your program to break (the compiler can't tell how much you rely on the size of your structs and whether you know about this rule, so it issues a warning).