C++ Struct packing order

Question

I have a union that looks similar to the following:

typedef
union _thing
{
    struct thing_indiv {
        uint16_t one:5;
        uint16_t two:4;
        uint16_t three:5;
        uint16_t four:5;
        uint16_t five:6;
        uint16_t six:6;
        uint16_t seven:6;
        uint16_t eight:7;
        uint16_t nine:4;
        uint16_t ten:5;
        uint16_t eleven:6;
        uint16_t twelve:5;
        uint16_t thirteen:5;
        uint16_t fourteen:4;
        uint16_t fifteen:2;
        uint16_t unused:5;
    } __attribute__((packed)) thing_split;
    uint8_t thing_comb[10];
    
} thing;

But it doesn't behave how I expect. I want to assign bytes to thing.thing_comb and retrieve the relevant items from thing.thing_split.

For example, if thing_comb = { 0xD6, 0x27, 0xAD, 0xB6. ..} I would expect thing.thing_split.one to contain 0x1A (the 5 most significant bits of 0xD6, but it does not, it contains 0x16, the 5 least significant bits. I declared each of the fields as uint16_t to keep gcc from complaining about crossing byte boundaries (I experience the same behavior with uint8_t).

Is there a way to lay out this struct to obtain this behavior?

*"crossing byte boundaries"*. You still have those `5+4+5 = 14`, `14 + 5 > 16`. — Jarod42, Nov 16 '20 at 18:29
oh, alright. Is there another mechanism I can use to obtain this behavior or am I forced to use bitwise operators to do what I need? — meatloaf, Nov 16 '20 at 18:30
bitfield is implementation specific, up to the compiler to use low, high (or mid) bit of underlying type. — Jarod42, Nov 16 '20 at 18:30
Maybe this is related to big vs small endians, https://stackoverflow.com/q/105252/14273548 — Uriya Harpeness, Nov 16 '20 at 18:32

score 2 · Answer 1 · answered Nov 16 '20 at 18:31

2

First, type punning with an union in C++ is Undefined Behaviour. Second, the Compiler is free to do anything it wants with a bitfield. It is not forced to lay it out like you want it to.

You need to use regular bit-packing with bitshifts to obtain the behaviour you want.

I had a similar question not so long ago: How to use bitfields that make up a sorting key without falling into UB?

answered Nov 16 '20 at 18:31

Raildex

3,406
1
18
42

1

bit fields are implementation defined, which means the compiler must document it and then act according to that documented behavior. What you write rather sounds like unspeicified which is something different – 463035818_is_not_an_ai Nov 16 '20 at 18:34
Yes you are right. But the important part is that it is indeed dependent on the compiler and different compilers will yield different results. What works on one machine will not work on another compiler. – Raildex Nov 16 '20 at 18:35
why quote a question when it has no answer? – 463035818_is_not_an_ai Nov 16 '20 at 18:35
"What works on one machine will not work on another machine." no, it means what works on one compiler will not work on a different compiler – 463035818_is_not_an_ai Nov 16 '20 at 18:36
@idclev463035818 the standard says that unions can only be accessed through the same member that they were created with. – Mark Ransom Nov 16 '20 at 18:36
@MarkRansom my complaint is about " Second, the Compiler is free to do anything it wants with a bitfield." which is about how bitfields are layed out in memory. Afaik this is implementation defined. Using it for type punning is the next step only – 463035818_is_not_an_ai Nov 16 '20 at 18:37
@MarkRansom ok, maybe I am reading something that the answer actually doesn't say. I'll shut up ;) – 463035818_is_not_an_ai Nov 16 '20 at 18:38
@idclev463035818 so the answer makes two points. You're using one point to complain about the other. – Mark Ransom Nov 16 '20 at 18:39
1

@idclev463035818: *"why quote a question when it has no answer?"*. There is one now :-) – Jarod42 Nov 16 '20 at 19:10
@Jarod42 thats a neat trick to advertise questions ;) – 463035818_is_not_an_ai Nov 16 '20 at 19:11

C++ Struct packing order

1 Answers1