What is the actual size of a struct in C

Question

Possible Duplicate:
struct sizeof result not expected
Struct varies in memory size?

Here is the code compiled on Ubuntu Server 11.10 for i386 machine:

// sizeof.c
#include <stdio.h>
#include <malloc.h>


int main(int argc, char** argv){
        printf("int's size: %d bytes\n", sizeof(int));
        printf("double's size: %d bytes\n", sizeof(double));
        printf("char's size: %d bytes\n", sizeof(char));
        printf("\n");

        printf("char pointer's size: %d\n", sizeof(char *));
        printf("\n");

        struct Stu{
                int id;
                char* name;
                char grade;
                char sex;
        //      double score;
        };
        printf("struct Stu's pointer's size : %d\n",sizeof(struct Stu *));

        struct Stu stu;
        stu.id=5;
        stu.name="Archer";
        stu.grade='A';
        stu.sex='M';
        printf("Stu(int,char*, char,char)'s size: %d bytes\n", sizeof(struct Stu));
        printf("Stu(5,\"Archer\",'A','M')'s size: %d bytes\n",sizeof(stu));
}

compile:

`gcc -o sizeof sizeof.c`

output:

int's size: 4 bytes
double's size: 8 bytes
char's size: 1 bytes

char pointer's size: 4

struct Stu's pointer's size : 4
Stu(int,char*, char,char)'s size: 12 bytes
Stu(5,"Archer",'A','M')'s size: 12 bytes

My question is why the size of struct Stu is 12, not sizeof(int) + sizeof(char *) + sizeof(char) + sizeof(char) = 4 + 4 + 1 + 1 = 10. When you put a double member intostruct Stu,sizeof(struct Stu)` will be 20.

Answer 1

To calculate the sizes of user-defined types, the compiler takes into account any alignment space needed for complex user-defined data structures. This is why the size of a structure in C can be greater than the sum of the sizes of its members. For example, on many systems, the following code will print 8:

refer http://en.wikipedia.org/wiki/Sizeof

Suppose you have the following structure:

struct A1
{
  char a[2];
  int b;
};

You could think that sizeof(A1) equates to 6, but it doesn’t. It equates to 8. The compiler inserts 2 dummy bytes between members ‘a’ and ‘b’.

The reason is that the compiler will align member variables to a multiple of the pack size or a multiple of the type size, whichever is smallest.

The default pack size in visual studio is 8 bytes.

‘b’ is of the integer type, which is 4 bytes wide. ‘b’ will be aligned to the minimum of those 2, which is 4 bytes. It doesn’t matter if ‘a’ is 1, 2, 3 or 4 bytes wide. ‘b’ will always be aligned on the same address.

refer for more details

Answer 2

Data has to be properly aligned for decent efficiency, so the compiler is at liberty to add padding to the interior of a structure (anywhere except at the start).

Generally, an N-byte type (for 1, 2, 4, 8, 16 bytes) is aligned on an N-byte address boundary.

Therefore, for a 32-bit compilation, the structure has:

    int id;          // offset =  0, size = 4
    char* name;      // offset =  4, size = 4
    char grade;      // offset =  8, size = 1
    char sex;        // offset =  9, size = 1
    double score;    // offset = 16, size = 8

For a total size of 24. Note that even if you moved the double around - say to the front of the structure, or to after the name, the size would still be 24 because all the elements of an array of the structure must be properly aligned, so there will be at least 6 bytes padding. (Sometimes, a double only needs to be aligned on a 4-byte boundary; the padding would then be 2 bytes instead of 6.)

Even without the double member, the structure must be 12 bytes long so that the id is properly aligned for the extra elements in an array - there would be 2 bytes of padding.

Some compilers provide programmers with a rope called #pragma pack or thereabouts, and some programmers leap at the opportunity to hang themselves with the rope thus provided.