Thread: Puzzled about the size of my data structure

Hi, I have created the following data type...

Code:

typedef struct tagLFSRType {
   union {
      struct {
         unsigned int bit0 : 1; // 
         unsigned int bit1 : 1; // 
         unsigned int bit2 : 1; // 
         unsigned int bit3 : 1; // 
         unsigned int bit4 : 1; // 
         unsigned int bit5 : 1; // 
         unsigned int bit6 : 1; // 
         unsigned int bit7 : 1; // 
         unsigned int bit8 : 1; // 
         unsigned int bit9 : 1; // 
         unsigned int bit10 : 1; // 
         unsigned int bit11 : 1; // 
         unsigned int bit12 : 1; // 
         unsigned int bit13 : 1; // 
         unsigned int bit14 : 1; // 
         unsigned int bit15 : 1; // 
         unsigned int bit16 : 1; // 
         unsigned int bit17 : 1; // 
         unsigned int bit18 : 1; // 
         unsigned int bit19 : 1; // 
         unsigned int bit20 : 1; // 
         unsigned int bit21 : 1; // 
         unsigned int bit22 : 1; // 
         unsigned int bit23 : 1; // 
         unsigned int bit24 : 1; // 
         unsigned int bit25 : 1; // 
         unsigned int bit26 : 1; // 
         unsigned int bit27 : 1; // 
         unsigned int bit28 : 1; // 
         unsigned int bit29 : 1; // 
         unsigned int bit30 : 1; // 
         unsigned int bit31 : 1; // 
      } b;               
      unsigned int value;
   } BitField;
   unsigned char length;
} LFSR_type;

When I print the sizeof(LFSR_type), I get 8. I would have expected to get 5. Also, when I create an array of them and print the addresses of them, the address increment by 8 as well.
Is there an obvious explanation for this?

Have you considered just using an unsigned 32 bit integer and just deleting this structure?

I would like to be able to access each of the bit values as a field.

Actually, this works well.

Code:

#define BIT(val, bit) ((val & (1 << bit)) >> bit)

int main(int argc, char *argv[])
{
   unsigned int value;
   int i;

   if (argc == 2) {
      sscanf(argv[1], "%8X", &value);
   } else {
      printf("Usage: %s <hex_value>\n", argv[0]);
      exit(EXIT_FAILURE);
   }

   for (i = 31; i >= 0; i--) {
      printf("%d", BIT(value, i));
      if ((i%4) == 0) printf(" ");
   }
   printf("\n");

   exit(EXIT_SUCCESS);
}

But thanks for your input.

The difference between expected and actual size is
because with structures the memory assigned is optimised
for the computer/compiler. This means a single byte may get
padded out to 4 bytes, depending on how it's aligned with the
rest of the structure variables, and also the optimisation the
compiler uses.Different compilers may use different optimisations,
so using sizeof() on the same structure on different systems may
provide different results.

Actually, this works well.

Are you aware that you are shifting back and forth?

I'd put a little more thought into that if I were you.

*shrug*

And anyways, this actually works better; "bit fields" can cause some problems especially when portability comes up.

Soma