Alignment of variables in structs

[Rick]

Given:

struct x
{
int i;
char c;
}st_x;

int size_of_struct = sizeof( struct x );
int size_of_st_x = sizeof( st_x );

struct x st_array[ 5 ];

int size_of_st_array = sizeof( st_array );

If an int is 32 bits and a char is 8 bits, are there any guarantees as
to what size_of_struct, size_of_st_x, or size_of_st_array evaluate to?
(they could be 5, 5, and 25, or 8, 8, and 40.)

Are there any rules that specify whether compilers are required to
align variables on any specific boundaries?

I tried all of this on gcc on cygwin on Windows XP and got
size_of_struct = 8, size_of_st_x = 8, and size_of_st_array = 40,
rather than what one might expect at first glance, size_of_struct = 5,
size_of_st_x = 5, and size_of_st_array = 25. Am I guaranteed to get
that on all platforms?

If there are any such guarantees, do any of you have a reference to a
document that says so?

Thanks...

 

[Eric Sosman]

Rick wrote On 11/29/07 13:41,:

Given:

struct x
{
int i;
char c;
}st_x;

int size_of_struct = sizeof( struct x );
int size_of_st_x = sizeof( st_x );

struct x st_array[ 5 ];

int size_of_st_array = sizeof( st_array );

If an int is 32 bits and a char is 8 bits, are there any guarantees as
to what size_of_struct, size_of_st_x, or size_of_st_array evaluate to?
(they could be 5, 5, and 25, or 8, 8, and 40.)

sizeof(struct x) == sizeof st_x, always.

sizeof st_array == 5 * sizeof(struct x), always.

sizeof(struct x) >= sizeof(int) + sizeof(char), always.

Are there any rules that specify whether compilers are required to
align variables on any specific boundaries?

The implementation is allowed but not required to have
alignment restrictions. The only "requirement" is the
vacuous one that a `char' has no alignment requirement (it
can reside at any address that is a multiple of 1).

I tried all of this on gcc on cygwin on Windows XP and got
size_of_struct = 8, size_of_st_x = 8, and size_of_st_array = 40,
rather than what one might expect at first glance, size_of_struct = 5,
size_of_st_x = 5, and size_of_st_array = 25. Am I guaranteed to get
that on all platforms?

No, although it's a common outcome. Presumably, the
compiler is trying to align each `int' to a four-byte
boundary. To make sure that both st_array[0].i and
st_array[1].i are properly aligned, the compiler must
ensure that sizeof(struct x) is a multiple of four, which
it does by inserting three unused "padding" bytes.

If there are any such guarantees, do any of you have a reference to a
document that says so?

There are no such guarantees -- which probably means
the Internet has *lots* of documents saying there are ;-)

 

[jameskuyper]

Given:

struct x
{
int i;
char c;
}st_x;

int size_of_struct = sizeof( struct x );
int size_of_st_x = sizeof( st_x );

struct x st_array[ 5 ];

int size_of_st_array = sizeof( st_array );

If an int is 32 bits and a char is 8 bits, are there any guarantees as
to what size_of_struct, size_of_st_x, or size_of_st_array evaluate to?
(they could be 5, 5, and 25, or 8, 8, and 40.)

There are some guarantees, just not as many as you thought:
size_of_struct >= sizeof(int)+sizeof(char)
size_of_struct == size_of_st_x
size_of_st_array == 5*size_of_struct

 

[SM Ryan]

# Are there any rules that specify whether compilers are required to
# align variables on any specific boundaries?

The struct is large enough to hold all fields, and every
field without a bit width is addressable (you can do
&(s.f)). Beyond that, ANSI C doesn't give you a lot of
guarentees.

Individual compilers may give you tighter guarentees
but then you're tied to those compilers.

You pays your money and you takes your chances.

# I tried all of this on gcc on cygwin on Windows XP and got
# size_of_struct = 8, size_of_st_x = 8, and size_of_st_array = 40,
# rather than what one might expect at first glance, size_of_struct = 5,
# size_of_st_x = 5, and size_of_st_array = 25. Am I guaranteed to get
# that on all platforms?

You're guarenteed sizeof(struct st_x)>=sizeof(int)+sizeof(char)
by ANSI C. gcc has options to pack with no alignment spacing; that
will get you a size of 5, even if it slows down the loads and stores.
However that is gcc specific.