C++ Substructure Bitfield Size

Question

Consider the following:

class A { public:
    int     gate_type :  4;
    bool storage_elem :  1;
    uint8_t privilege :  2;
    bool      present :  1;
} __attribute__((packed));

class B { public:
    struct Sub {
        int     gate_type :  4;
        bool storage_elem :  1;
        uint8_t privilege :  2;
        bool      present :  1;
    } type_attr; //Also tried with "__attribute__((packed))" here in addition to outside
} __attribute__((packed));

Compiler is g++ 4.8.1. sizeof(A)==1, sizeof(B)==4. Why is this so? I need something like structure B to have size 1.

Answer 1

This may seem like a dumb counter-question. I get the result you desire when I rewrite your example as:

class A { public:
    int     gate_type :  4;
    bool storage_elem :  1;
    uint8_t privilege :  2;
    bool      present :  1;
} __attribute__((packed));

class B { public:
    A type_attr; //Also tried with "__attribute__((packed))" here in addition to outside
};

Is there some reason you can't reuse the definition of class A inside of class B ? This really seems to be the better way to do it.

As I recall, neither C nor C++ guarantee that struct Sub would have identical layout to and have identical storage requirements as class A , despite having the same field widths, order and so on. (In C's case, it'd be struct Sub vs. struct A , but the same idea holds, since these are all POD types.)

The exact behavior ought to be ABI-dependent. By reusing class A as I did above, though, I think you make yourself slightly more immune to ABI issues. (Slightly, not impervious.)