How is the Size of the struct calculated correctly?

Question

What would be the size of MyStruct on windows 7 , 64 bit ?

    typedef struct MyStruct_tag
   {
       char        c;
       double      d;
       int         s;
    } MyStruct;

My answer:

1 (Char) + 7 (Padding) + 8 (double) + 4 (int) = 20 bytes

But the answer is coming out 24 bytes. What is going on ?

Read the answer given below and the answers in the linked question. — haccks, Aug 11 '14 at 08:52

score 4 · Answer 1 · answered Aug 11 '14 at 08:49

4

The final int is likely followed by 4 bytes of padding so that the alignment of the double in the next similar struct in an array will be properly aligned.

But ultimately, padding is implementation-defined. Trying to reason about or predict it isn't useful. The compiler should take care of it for you. If it doesn't, strongly reconsider what you're doing.

answered Aug 11 '14 at 08:49

Robert Allan Hennigan Leahy

6,478
28
45

2

You can use `__attribute__((packed))` to specify that you don't wants the struct attributes to be aligned (not the best practice). – Pierre Emmanuel Lallemant Aug 11 '14 at 08:52

score 2 · Answer 2 · answered Aug 11 '14 at 08:52

It's for ``alignment''. Many processors can't access 2- and 4-byte quantities (e.g. ints and long ints) if they're crammed in every-which-way.

Suppose you have this structure:

struct  {
    char a[3];
    short int b;
    long int c;
    char d[3];
    };

Now, you might think that it ought to be possible to pack this structure into memory like this:

+-------+-------+-------+-------+
|           a           |   b   |
+-------+-------+-------+-------+
|   b   |           c           |
+-------+-------+-------+-------+
|   c   |           d           |
+-------+-------+-------+-------+

But it's much, much easier on the processor if the compiler arranges it like this:

+-------+-------+-------+
|           a           |
+-------+-------+-------+
|       b       |
+-------+-------+-------+-------+
|               c               |
+-------+-------+-------+-------+
|           d           |
+-------+-------+-------+

In the packed'' version, notice how it's at least a little bit hard for you and me to see how the b and c fields wrap around? In a nutshell, it's hard for the processor, too. Therefore, most compilers willpad'' the structure (as if with extra, invisible fields) like this:

+-------+-------+-------+-------+
|           a           | pad1  |
+-------+-------+-------+-------+
|       b       |     pad2      |
+-------+-------+-------+-------+
|               c               |
+-------+-------+-------+-------+
|           d           | pad3  |
+-------+-------+-------+-------+

Courtesy - Steve Summit

In the maps above are you assuming that int is 2 byte? – user2799508 Aug 11 '14 at 08:58 — user2799508, Aug 11 '14 at 08:58

How is the Size of the struct calculated correctly?

2 Answers2