Question

Once again, I’m questioning a longstanding belief.

Until today, I believed that the alignment of the following struct would normally be 4 and the size would normally be 5…

struct example
{
  int   m_Assume_32_Bits;
  char  m_Assume_8_Bit_Bytes;
};

Because of this assumption, I have data structure code that uses offsetof to determine the distance in bytes between two adjacent items in an array. Today, I spotted some old code that was using sizeof where it shouldn’t, couldn’t understand why I hadn’t had bugs from it, coded up a unit test – and the test surprised me by passing.

A bit of investigation showed that the sizeof the type I used for the test (similar to the struct above) was an exact multiple of the alignment – ie 8 bytes. It had padding after the final member. Here is an example of why I never expected this…

struct example2
{
  example m_Example;
  char    m_Why_Cant_This_Be_At_Offset_6_Bytes;
};

A bit of Googling showed examples that make it clear that this padding after the final member is allowed – for example http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding (the “or at the end of the structure” bit).

This is a bit embarrassing, as I recently posted this comment – Use of struct padding (my first comment to that answer).

What I can’t seem to determine is whether this padding to an exact multiple of the alignment is guaranteed by the C++ standard, or whether it is just something that is permitted and that some (but maybe not all) compilers do.

So – is the size of a struct required to be an exact multiple of the alignment of that struct according to the C++ standard?

If the C standard makes different guarantees, I’m interested in that too, but the focus is on C++.

Answer 1

One definition of alignment size:

The alignment size of a struct is the offset from one element to the next element when you have an array of that struct.

By its nature, if you have an array of a struct with two elements, then both need to have aligned members, so that means that yes, the size has to be a multiple of the alignment. (I’m not sure if any standard explicitly enforce this, but because the size and alignment of a struct don’t depend on whether the struct is alone or inside an array, the same rules apply to both, so it can’t really be any other way.)