GCC和Visual Studio（32位控制器）中结构大小的差异

Question

As shown in below structure, 1 byte should be padded after var1 and since short is used in structure, one more byte is padded after var3 . With this, the total should be 6. That is the value I am getting in Visual Studio. It is also mentioned at Wikipedia on Data structure alignment .

typedef struct {char var1; short var2; char var3;} Bytes;

But in GCC it is giving the size as 8 bytes. Please let me know about the behaviour.

---

Hi Jack,

I did experement with below structure.

typedef struct
{
    char  charVar1;
    short shortVar2;
    char  charVar3;
}tsByte;

printf("\n Sizeo of Byte        : %d", sizeof(Byte));
printf("\n Sizeo of charVar1    : %d", sizeof(Byte.charVar1));
printf("\n Sizeo of shortVar2   : %d", sizeof(Byte.shortVar2));
printf("\n Sizeo of charVar3    : %d", sizeof(Byte.charVar3));
printf("\n Address of charVar1  : %x", &Byte.charVar1);
printf("\n Address of shortVar2 : %x", &Byte.shortVar2);
printf("\n Address of shortVar3 : %x", &Byte.charVar3);

and the results are as below.

Sizeo of Byte        : 8
Sizeo of charVar1    : 1
Sizeo of shortVar2   : 2
Sizeo of charVar3    : 1
Address of charVar1  : 4007e90
Address of shortVar2 : 4007e92
Address of shortVar3 : 4007e94

Usually padding at the end of a structure is necessary to ensure proper alignment (of all of its members) when the structure is used as an element of an array. But bit confused with padding for last element. Whether padding "for last element" is based on the 8/16/32-bit controller architecture or based on the biggest member size (here short).

I feel in Visual studio it is based on biggest member size and so you are getting size as 6 bytes. Whereas with gcc compiler it is based on controller architecture and since I am using 32-bit controller it is aligned with 4-byte memory. Because of this in gcc compiler it is 8 bytes. Please correct me if I am wrong.

Answer 1

You will need to write a bit more code to investigate the differences between compilers. For example, try a code fragment such as:

    // define a structure
    typedef struct {char var1; short var2; char var3;} Bytes;

    // allocate storage for the structure
    Bytes data;

    // tell me stuff about that structure
    printf("\nsizeof Bytes=%d, sizeof var1=%d, sizeof var2=%d, sizeof var3=%d",
         sizeof(data), sizeof(data.var1), sizeof(data.var2), sizeof(data.var3));

On Eclipse/Microsoft C compiler, I got:

    sizeof Bytes=6, sizeof var1=1, sizeof var2=2, sizeof var3=1

So, why is Bytes=6 but the sizeof vars sum to 4? This is answered by the following:

    printf("\naddrof var1=%08x", &data.var1);
    printf("\naddrof var2=%08x", &data.var2);
    printf("\naddrof var3=%08x", &data.var3);

Which produces:

    addrof data=0012ff40
    addrof var1=0012ff40
    addrof var2=0012ff42
    addrof var3=0012ff44

And so, even though var1 is a char it uses two bytes, thus the Microsoft C compiler implements ANSI C as documented by K&R!!

You will need to run similar code using GCC to determine exactly how it is formatting the struct Bytes .

Answer 2

As shown in below structure, 1 byte should be padded after 'var1' and since short is used in structure, one more byte is padded after 'var3'. With this, the total should be 6.

Wrong. The C language does not stipulate what the total size must be -- it is implementation-defined. The compiler is free to add padding bytes between members or at the end of the structure as it sees fit. It may choose to add no padding, to align members on 2- or 4-byte boundaries, or something else entirely. All of those behaviors are allowed by the C standard.

The fact that different compilers product different values just demonstrates that not all compilers are the same. Both compilers are compliant with the C standard in this regard.

Answer 3

If you require specific alignment, you can always user #pragma pack :

• http://msdn.microsoft.com/en-us/library/2e70t5y1.aspx

• http://gcc.gnu.org/onlinedocs/gcc/Structure_002dPacking-Pragmas.html

And as others have already noted, you can use the sizeof() operator and the Standard C offsetof() macro to determine the actual alignment for your particular combination of struct definition, compiler, and alignment settings.