Thread: Storing an integer in a struct

I am trying to store a 16 big integer inside a struct, I'd like to know if there is a fast way of doing so?

Code:

struct memstatreg
{
    unsigned int a:1;
    unsigned int b:1;
    unsigned int c:1;
    unsigned int d:5;
    unsigned int e:3;
    unsigned int f:1;
    unsigned int g:4; //16bits 
}F_STATUS;

unsigned int i=0x7BAB; // eq. 0111101110101011b

my result should be :

|_g__|f|__e_|__d__|c|b|a|
|0111|1|011|10101|0|1|1|

I think since each variable in the struct is declared unsigned int, this preserves 16*7(128) bits in memory and setting F_STATUS=i would mean trying to equate 128bits in memory with 16 bits?
The only method i can think of is using bitwise operations which is fine for me however the code can get quite messy.

Code:

union fields_u {
  unsigned short value;

  // Anonymous structure...
  struct {
    unsigned short a:1;
    unsigned short b:1;
    unsigned short c:1;
    unsigned short d:5;
    unsigned short e:3;
    unsigned short f:1;
    unsigned short g:4;
  };
};

// Usage:
union fields_u x;

x.value = 0x7bab;

// print the fields:
printf( "a:%u, b:%u, c:%u, d:0x%hx, e:0x%hx, f:%u, g:0x%hx\n",
  x.a, x.b, x.c, x.d, x.e, x.f );

But, be careful... bit fields can be tricky. I advise to use the attribute 'packed' (or the pragma 'pack') to garantee the bits are tighter as possible...

A small correction on my last comment: pragma "pack" refers to types alignment, not bit packing.

The standard tells us about bit fields, but it says bit packing is "implementation dependant". So, it is advisable to use the compiler extension, if there is one, to pack them as tight as possible:

Code:

union fields_u {
  unsigned short value;
 
  // Anonymous structure...
  struct {
    unsigned short a:1; // this could be a single bit followed by 15 unused bits...
    unsigned short b:1;
    unsigned short c:1;
    unsigned short d:5; // this could be 5 useful bits followed by 11 unused bits...
    unsigned short e:3; // this could be 3 useful bits followed by 13 unused bits...
    unsigned short f:1;
    unsigned short g:4; // this could be 4 useful bits followed by 12 unused bits...
  } __attribute__((packed)); // this packs everything as tight as possible....
};

This __attribute__((packed)) is available only on GCC. Visual Studio and other compilers may have different ways to do the same thing...

Originally Posted by john.c

Nope. Bits are always "packed" if possible (that's the whole point!). "If enough space remains, a bit-field that immediately follows another bit-field in a structure shall be packed into adjacent bits of the same unit." (n1256 6.7.2.1:10)

However, it is implementation defined whether you can use a short. And of course the endianness will be a factor in your union trick.

Yep... strangely only _Bool, signed and unsigned int (by 6.7.2.1:4) are garanteed (_Bool?! 6.2.5 defines as "large enough to store 0 or 1"!!!).

But 6.7.2.1:10 states:

An implementation may allocate any addressable storage unit large enough to hold a bit-field. If enough space remains, a bit-field that immediately follows another bit-field in a structure shall be packed into adjacent bits of the same unit...

Everything else is implementation defined.

So, bits-fields are not always packed!