Forcing enum field to 8 bits in standard C with bitfields

Question

I saw few questions here about how to force an enum to 8 or 16 bits. The common answer was that it can be done in C++11 or higher. Unfortunately, I don't have that luxury.

So, here is what I'm thinking. I only need the enum to be 8 bits when it's in a struct whose size I want to minimize. So:

Option A:

typedef enum { A, B, C, MAX = 0xFF } my_enum;

struct my_compact_struct
{
    my_enum field1 : 8; // Forcing field to be 8 bits 
    uint8_t something;
    uint16_t something_else;
};

I think most or all optimizers should be smart enough to handle the 8 bitfield efficiently.

Option B:

Not use an enum. Use typedef and constants instead.

typedef uint8_t my_type;

static const my_type A = 0;
static const my_type B = 1;
static const my_type C = 2;

struct my_compact_struct
{
    my_type field1; 
    uint8_t something;
    uint16_t something_else;
};

Option A is currently implemented and seems to be working, but since I want to do (now and in the future) what's correct now and not just what's working, I was wondering if option B is clearly better.

Thanks,

(A) won't minimize the field. It will only make 8 bits of the whole field usable — StoryTeller - Unslander Monica, Jan 25 '17 at 14:08
Your question states "Standard C" but your tags include "c++". Which are you using? — François Andrieux, Jan 25 '17 at 14:09
You cannot do this in *standard* C, no. In C++ it is possible since C++11. — DeiDei, Jan 25 '17 at 14:11
It is a bad idea to use variables as constant masks. `const` does not introduce a constant in C. Use `#define`s` or an `enum`. Apart from that the second approach is fine. — too honest for this site, Jan 25 '17 at 14:11
@StoryTeller will it matter if I guarantee that my enum values are at most 0xFF? — Elad Weiss, Jan 25 '17 at 14:11
Sidenote: use self-explanatory names for the constants, best prefixed with the name of the type they relate to. — too honest for this site, Jan 25 '17 at 14:15
Long story short, keep the enum. Make the field a `uint8_t` and document where the set of flags is to be taken from. There's little point defining the field as `my_enum` since `A | B` does not produce a value listed in the enumeration. — StoryTeller - Unslander Monica, Jan 25 '17 at 14:16
@StoryTeller: Agreed, that works for `uint8_t`, because an `int` is always larger. It already causes problems for `uint16_t` if you need the full range. — too honest for this site, Jan 25 '17 at 14:19
@Olaf so this approach will better than typedef + defines (option B)? — Elad Weiss, Jan 25 '17 at 14:23
@EladWeiss At some point, you can't use `enum`s, so `typedef`+ constant-marcros is more consistent if you have multiple such constructs. But I'm split in halves and I use both. As a personal note: I can't understand why the C commitee did not allow `enum`s to specify the tape similar to C++11 does. It would not break legacy code, but would make `enum`s really usable for embedded programming for the first time. It is worse, because embedded is the major field to use C. — too honest for this site, Jan 25 '17 at 14:53
@Olaf - The C++11 change was probably done to "steal market share" from C in the embedded world. — StoryTeller - Unslander Monica, Jan 25 '17 at 15:00
@StoryTeller: My point is not why C++ did add this, but my C11 did **not**. Would have been a minor addition, not much complicate to add to compilers. But likely the same reason why VLAs were made optional (against the commitee's mantra of backwards-compatibility: some commercial compiler vendors wanted to make money with the least effort). — too honest for this site, Jan 25 '17 at 15:14

Bathsheba · Accepted Answer · 2017-01-25T14:16:15.587

4

If your specific values in an enum can fit into a smaller type than an int, then a C implementation is free to choose the underlying type of the enum to be a smaller type than an int (but the type of the enum constants in this case will be int). But there is no way you can force a C compiler to use a type smaller than an int. So with this in mind and the fact that an int is at least 16 bits, you're out of luck.

But enums in C are little more than debugging aids. Just use an uint8_t type if you compiler has it:

static const uint8_t something = /*some value*/

If not then use a char and hope that CHAR_BIT is 8.

edited Jan 25 '17 at 14:16

answered Jan 25 '17 at 14:11

Bathsheba

231,907
34
361
483

The implementation is free to choose a smaller type for an `enum`. But the constants are **always** `int`. And `const` does not qualify a constant. C has no symbolic constants other than `enum-constants` (which are indeed near useless if you need any other type than `int`) – too honest for this site Jan 25 '17 at 14:16
@Olaf: Remind me never to take the opposing side to you in a pub quiz. – Bathsheba Jan 25 '17 at 14:20
Interesting... a former boss of mine said something very similar :-) – too honest for this site Jan 25 '17 at 14:21

score 2 · Answer 2 · answered Jan 25 '17 at 14:11

2

Option B would be best. You'd be defining the type in question to be a known size, and the const values you define will also be the correct size.

While you would lose out on the implicit numbering of an enum, the explicit sizing of the field and its values makes up for it.

answered Jan 25 '17 at 14:11

dbush

205,898
23
218
273

3

The `const` values are not constants, though. An `enum` for the constants or `#define`s are better. (I recommend the latter, because you can specify the type). – too honest for this site Jan 25 '17 at 14:12

score 2 · Answer 3 · edited May 01 '23 at 23:27

Step into same problem, I solved it this by using __attribute__((packed)). Packed align data to 4 Bytes, with packed (int)sizeof(my_compact_struct) = 4, without packed (int)sizeof(my_compact_struct) = 8

typedef enum __attribute__((packed)){ 
A = 0x01
B = 0x10
C = 0x255 // Max value, or any other lower than this
} my_enum;

struct my_compact_struct __attribute__((packed)){
    my_enum field1 : 8; // Forcing field to be 8 bits 
    uint8_t something;
    uint16_t something_else;
};

score 0 · Answer 4 · answered Aug 30 '18 at 06:21

You can use enum or even typedef enum like a grouped #define. Do not actually define a structure member, data stream, or global variable as type enum. Rather define all storage members as fixed types like uint8_t. As if you used #define just set them to the enum literal constants. If you use any kind of lint tool, then this design style will raise some messages which you will need to tailor. Just like malformed #define if the literal value doesn't fit, then bad things can happen, and either way you need to pay attention. In a debugger or hardware simulator, the enum can provide useful display reference information. Temporary variables are an exception to how global definitions are treated. For function parameters or automatic variables, and only then, define them with the enum type. In this context int is going to be the most efficient word size as well as the standard behavior of enum. There is no error possible nor hyper-optimizing you can do.

Forcing enum field to 8 bits in standard C with bitfields

4 Answers4

Linked