Field alignment of a struct in C/C++

Are the members o开发者_开发技巧f a structure packed in C/C++?

By packed I mean that they are compact and among the fields there aren't memory spaces.

That isn't what aligned means, and no, no particular alignment or packing is guaranteed. The elements will be in order, but the compiler can insert padding where it chooses. This actually creates (useful) alignment. E.g., for a x86:

struct s
{
  char c;
  int i;
};

there will probably (but not necessarily) be three bytes between c and i. This allows i to be aligned on a word boundary, which can provide much faster memory access (on some architectures, it's required).

From C99 §6.7.2.1:

Each non-bit-field member of a structure or union object is aligned in an implementation- defined manner appropriate to its type.

What you are asking for is packing, and alignment is different. Both are outside of the scope of the language and are specific for each implementation. Take a look here.

Generally not. Some info here.

Depending on the compiler, you can introduce pragmas to help (from the link above):

#pragma pack(push)  /* push current alignment to stack */
#pragma pack(1)     /* set alignment to 1 byte boundary */

struct MyPackedData
{
    char Data1;
    long Data2;
    char Data3; 
};

#pragma pack(pop)   /* restore original alignment from stack */

Typically (but under no guarantees), members of a struct are word-aligned. This means that a field less than the size of a word will be padded to take up an entire word.

However, when the next member of the struct can also fit inside the same word, then the compiler will put both members into the same word. This is more efficient space-wise, but depending on your platform, retrieving said members might be more expensive computationally.

On my 32-bit system using GCC under Cygwin, this program...

#include <iostream>

struct foo
{
    char a;
    int b;
    char c;
};

int main(int argc, char** argv)
{
    std::cout << sizeof(foo) << std::endl;
}

outputs '12' because both chars are word-aligned and take up 4 bytes each.

However, switch the struct to

struct foo
{
    char a;
    char c;
    int b;
};

and the output is '8' because both chars next to each other can fit in a single word.

It is possible to pack bytes in order to conserve memory. For instance, pack(2) will tell members that longer than a byte to pack to two-bytes in order to maintain a two-byte boundary so that any padding members are two bytes long. Sometimes packing is used as part of a standard communication protocol where it expects a certain size. Here is what Wikipedia has to say about C/C++ and padding:

Padding is only inserted when a structure member is followed by a member with a larger alignment requirement or at the end of the structure. By changing the ordering of members in a structure, it is possible to change the amount of padding required to maintain alignment. For example, if members are sorted by ascending or descending alignment requirements a minimal amount of padding is required. The minimal amount of padding required is always less than the largest alignment in the structure. Computing the maximum amount of padding required is more complicated, but is always less than the sum of the alignment requirements for all members minus twice the sum of the alignment requirements for the least aligned half of the structure members.

Although C and C++ do not allow the compiler to reorder structure members to save space, other languages might.

Since in struct's, the compiler treats things as words, sometimes care must be taken if you are relying on the size of the struct to be a certain size. For instance, aligning char vs int.

They are not packed by default. Instead, they are word-aligned depending on how your machine is set up. If you do want them to be packed. Then you can use __attribute__((__packed__)) at the end of your struct declaration like this:

struct abc {
  char a;
  int b;
  char c;
}__attribute__((__packed__));

Then, for

struct abc _abc;

_abc will be packed.

Reference: Specific structure packing when using the GNU C Compiler

Seeing some outputs of the same structure's variations may give a clue about what is going on. After reading this, if I did not get it wrong, small types will be padded to be a word-lengths.

struct Foo {
   char x ;  // 1 byte
   int y ;   // 4 byte
   char z ;  // 1 byte
   int w ;   // 4 byte
};
struct FooOrdered {
   char x ;  // 1 byte
   char z ;  // 1 byte
   int y ;   // 4 byte
   int w ;   // 4 byte
};


struct  Bar {
   char x ;  // 1 byte
   int w ;   // 4 byte
};
struct  BarSingleType {
   char x ;  // 1 byte
};

int main(int argc, char const *argv[]) {
    cout << sizeof(Foo) << endl;
    cout << sizeof(FooOrdered) << endl;
    cout << sizeof(Bar) << endl;
    cout << sizeof(BarSingleType) << endl;
    return 0;
}

In my environment output was like this:

16
12
8
1