Alignment of variables in structs

Discussion in 'C Programming' started by Rick, Nov 29, 2007.

  1. Rick

    Rick Guest

    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...
    Rick, Nov 29, 2007
    #1
    1. Advertising

  2. Rick

    Eric Sosman Guest

    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 ;-)

    --
    Eric Sosman, Nov 29, 2007
    #2
    1. Advertising

  3. Rick

    Guest

    Rick wrote:
    > 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
    , Nov 29, 2007
    #3
  4. Rick

    SM Ryan Guest

    Rick <> wrote:

    # 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.

    --
    SM Ryan http://www.rawbw.com/~wyrmwif/
    Leave it to the Catholics to destroy existence.
    SM Ryan, Nov 30, 2007
    #4
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Patricia  Van Hise

    structs with fields that are structs

    Patricia Van Hise, Apr 5, 2004, in forum: C Programming
    Replies:
    5
    Views:
    635
    Al Bowers
    Apr 5, 2004
  2. Chris Hauxwell

    const structs in other structs

    Chris Hauxwell, Apr 23, 2004, in forum: C Programming
    Replies:
    6
    Views:
    557
    Chris Hauxwell
    Apr 27, 2004
  3. Paminu
    Replies:
    5
    Views:
    639
    Eric Sosman
    Oct 11, 2005
  4. Daniel Rudy
    Replies:
    15
    Views:
    1,394
    Keith Thompson
    Apr 10, 2006
  5. Rick
    Replies:
    1
    Views:
    258
    Victor Bazarov
    Nov 29, 2007
Loading...

Share This Page