How structure padding works?

问题:

My Questing is regarding structure padding? Can any one tell me what's logic behind structure padding.

Example:

structure Node{ char c1; short s1; char c2; int i1; };

Can any one tell me how structure padding will apply on this structure?

Assumption: Integer takes 4 Byte.

Waiting for the answer.

回答1:

How padding works depends entirely on the implementation.

For implementations where you have a two-byte short and four-byte int and types have to be aligned to a multiple of their size, you will have:

Offset  Var   Size
------  ----  ----
   0     c1      1
   1     ??      1
   2     s1      2
   4     c2      1
   5     ??      3
   8     i1      4
  12    next

An implementation is free to insert padding between fields of a structure and following the last field (but not before the first field) for any reason whatsoever. The ability to pad after a structure is important for aligning subsequent elements in an array. For example:

struct { int i1; char c1; };

may give you:

Offset  Var   Size
------  ----  ----
   0     i1      4
   4     c1      1
   5     ??      3
   8    next

Padding is usually done because either aligned data works faster, or misaligned data is illegal (some CPU architectures disallow misaligned access).

回答2:

There is no simple answer to this, except "It depends".

It could be as little as 8 bytes, assuming two byte shorts, or it could take 12 bytes, or it could take 42 bytes on a suitably bizarre implementation. It depends on at least the underlying architecture, the compiler and the compiler flags. Check your tool's manual for information.

回答3:

Inside a struct, each member's offset in memory is based on their size and alignment. Note that this is implementation specific

E.g. if char takes 1 byte, short takes 2 bytes and int takes 4 bytes:

structure Node{ 
    char c1;  // 1 byte
              // 1 byte padding (next member requires 2 byte alignment)
    short s1; // 2 bytes
    char c2;  // 1 byte
              // 3 bytes padding (since next member requires 4 byte alignment)
    int i1;   // 4 bytes
};

This also depends on your compiler settings and architecture, and can also be modified.

If you packed this structure properly (by rearranging the order of members), you could fit it into 8 bytes, not 12 bytes (by switching c2 with s1).

The reason for alignment enforcement is that the hardware can do certain operations faster with data that have a natural alignment; otherwise it would have to perform some bitmasking, shifting and ORing to construct the data before operating on it.