Question

I was just playing around with bit fields and came across something that I can’t quite figure out how to get around.

(Note about the platform: size of an int = 2bytes, long = 4bytes, long long = 8bytes – thought it worth mentioning as I know it can vary. Also the ‘byte’ type is defined as an ‘unsigned char’)

I would like to be able to make an array of two 36 bit variables and put them into a union with an array of 9 bytes. This is what I came up with:

typedef union {
  byte bytes[9];
  struct {
    unsigned long long data:36;
  } integers[2];
} Colour;

I was working on the theory that the compiler would realise there was supposed to be two bitfields as part of the anonymous struct and put them together into the space of 9 bytes. However it turns out that they get aligned at a byte boundary so the union occupies 10 bytes not 9, which makes perfect sense.

The question is then, is there a way to create an array of two bit fields like this? I considered the ‘packed’ attribute, but the compiler just ignores it.

While this works as expected (sizeof() returns 9):

typedef union {
  byte bytes[9];
  struct {
    unsigned long long data0:36;
    unsigned long long data1:36;
  } integers;
} Colour;

It would be preferable to have it accessible as an array.

---

Edit:
Thanks to cdhowie for his explanation of why this won’t work.

Fortunately I thought of a way to achieve what I want:

typedef union {
  byte bytes[9];
  struct {
    unsigned long long data0:36;
    unsigned long long data1:36;
    unsigned long long data(byte which){
      return (which?data1:data0);
    }
    void data(byte which, unsigned long long _data){
      if(which){
        data1 = _data;
      } else {
        data0 = _data;
      }
    }
  } integers; 

} Colour; 

Answer 1

You can’t directly do this using arrays, if you want each bitfield to be exactly 36 bits wide.

Pointers must be aligned to byte boundaries, that’s just the way pointers are. Since arrays function like pointers in most cases (with exceptions), this is just not possible with bitfields that contain a number of bits not evenly divisible by 8. (What would you expect &(((Colour *) 0)->integers[1]) to return if the bitfields were packed? What value would make sense?)

In your second example, the bitfields can be tightly-packed because there is no pointer math going on under the hood. For things to be addressable by pointer, they must fall on a byte boundary, since bytes are the units used to “measure” pointers.

You will note that if you try to take the address of (((Colour *) 0)->integers.data0) or data1 in the second example, the compiler will issue an error, for exactly this reason.