Thread: sizeof applied to structure...

A word is 2 bytes. 32-bit systems more often align to a double word (4 bytes). #pragma pack() is pretty common place for overriding the default boundaries. Though I would only do that when you know its what you should be doing. Unions are also capable (and a more portable solution) of changing the alignment of a structure.

Code:

union node
{
  struct
  {
    int data;
    char c;
  };

  char raw[5];
};

Originally Posted by Cooloorful

#pragma pack() is pretty common place for overriding the default boundaries.

Careful. That's a GCC-specific pragma.
All pragmas are compiler-specific and there's no mention of what compiler the OP is using.
Also, don't mess with the padding if you don't have a good reason to. The compiler does it for a reason (performance).

*sigh* I love how when this topic clicks, all is well in the universe. If kids learned assembler first nowadays I think perhaps it would be more intuitive.

A char is one byte.

Code:

void function1(void)
{
  int c;
  char d;
  float h;

  printf("c is %d bytes\nb is %d bytes\nh is %d bytes\n", sizeof c, sizeof d, sizeof h);
  printf("The distance from c to h is %d bytes", (char *)(&h + 1) - (char *)(&c));
}

The problem with data being aligned on weird boundaries is that it makes the stack run less efficiently since it keeps needing to realign the stack to different boundaries.

Code:

void function2(void)
{
  struct {
    int c;
    char d;
    float h;
  } t;

  printf("t.c is %d bytes\nt.b is %d bytes\nt.h is %d bytes\nt is %d bytes\n", sizeof t.c, sizeof t.d, sizeof t.h, sizeof t);
  printf("The distance from t.c to t.h is %d bytes", (char *)(&t.h + 1) - (char *)(&t.c));
}

The structure aligns data more efficiently. Its an invisible characteristic that won't effect your code at all. It does become an issue when parsing binary files, however.

Originally Posted by Cooloorful

*sigh* I love how when this topic clicks, all is well in the universe. If kids learned assembler first nowadays I think perhaps it would be more intuitive.

And go through the horrors of writing assembly code? No thanks.
I think they should be content with the fact that the compiler can pad structs. For performance reasons.

Originally Posted by roaan

# pragma pack(). I am hearing this for the first time ?????

Again, a more platform independant way to accomplish the task is to use a union. But since you are asking, #pragma directives are simply directives only specific compilers even listen to. They are not standardized at all. The only thing standard about them is they all have to begin with #pragma. pack is in the gcc and MSVC family of directives (though the syntax can vary) which simply tells the compiler to align it how you are telling it to, not how it wants to.

Example:

Code:

#pragma pack(1)

struct node
{
  struct node *next;
  char ch;
};

Now when you do your sizeof it should be 5.

Originally Posted by Elysia

And go through the horrors of writing assembly code? No thanks.
I think they should be content with the fact that the compiler can pad structs. For performance reasons.

While I do not disagree with that, I think understanding why it does so is more a matter of fact in a high level language such as C/C++ whereas in assembler its very intuitive and obvious.

Originally Posted by bithub

Not all compilers support this, and there is almost never a time where using it is a good idea.

Agreed! But whether or not you should use it, you are now informed that it does exist and how to use it.

Originally Posted by Cooloorful

While I do not disagree with that, I think understanding why it does so is more a matter of fact in a high level language such as C/C++ whereas in assembler its very intuitive and obvious.

Ah, but the question is, do I really have to know?
Assembler is not a very friendly language, after all, and being as much machine-independent as possible makes for very portable code.

I know people tend to ask stupid questions sometimes. Perhaps they should attend to a hardware engineering course of some sort. But I don't think using assembler before is a good thing.

Code:

The structure aligns data more efficiently.

Huh? No. Having your data in a struct does not magically bestow good karma onto it. Here's the graphical layout of your stack & structure examples, on my machine:

Code:

Stack:
+-------+-----+-+-------+
| h     | ?   |d| c     |
+-------+-----+-+-------+
 0 1 2 3 4 5 6 7 8 9 a b

Struct:
+-------+-+-----+-------+
| c     |d| ?   | h     |
+-------+-+-----+-------+
 0 1 2 3 4 5 6 7 8 9 a b

Furthermore, I get different answers for the stack one, depending on whether or not I actually use those variables. And this is with optimizations off.
As for packing, there's usually not a use for that (I've never needed it.). Write portable serialization code, and let your compiler have free reign over where your variables are.