Aman Prasad

Posted on Jan 10

Bit Fields in C Explained: How They Work and Why They Matter

#programming #discuss #learning #coding

We often use full integers to store simple flags that need only one bit. Bit fields in C seem like an easy way to save memory by using just the bits we need.
But this simplicity hides compiler and hardware details that can change how the data is actually stored in memory.

What Are Bit Fields?

A bit field is a special struct member that allows you to specify exactly how many bits a variable should occupy, rather than using the standard byte-aligned sizes.

struct Date {
    unsigned int day   : 5;  // 5 bits (Range: 0-31)
    unsigned int month : 4;  // 4 bits (Range: 0-15)
    unsigned int year  : 11; // 11 bits (Range: 0-2047)
};

Instead of allocating a full int (typically 32 bits) for each member, the compiler may pack these fields together to reduce memory usage.

Syntax and basic rules

A bit field is defined by placing a colon : after a structure member name, followed by the number of bits it should use.
Bit fields can only be declared inside a struct. They cannot exist as standalone variables.
Bit fields are not addressable objects in C, so the address-of operator (&) cannot be used on them.

Bit Fields vs Normal Structure Members

This behavior contrasts with normal structure members.

Normal structure members are aligned to byte boundaries, so each int usually consumes 4 bytes, even if it stores only a small value.
Bit field members, on the other hand, can be packed into adjacent bits within a machine word, allowing multiple small values to share the same underlying storage.

The trade-off is clear: normal members offer predictable layout, while bit fields trade layout guarantees for compactness and expressiveness.

How Compilers Actually Store Bit Fields

This is where bit fields stop being simple.
When you write a structure like this:

struct Flags {
    unsigned int a : 1;
    unsigned int b : 1;
    unsigned int c : 1;
};

It is natural to assume that these fields are placed in memory one after another, each occupying a single bit in order, for example:

bit 0 -> a
bit 1 -> b
bit 2 -> c

However, the C standard does not guarantee any such layout.
Bit fields are stored inside a larger storage unit, typically the base type used in their declaration such as unsigned int. How individual bit fields are placed within that storage unit is largely decided by the compiler.

In particular, the C standard does not define:

the ordering of bits within a word (LSB vs MSB)
how bit fields are packed across bytes
alignment and padding rules

Two different compilers targeting the same architecture are therefore allowed to produce different memory layouts for the same bit-field structure.

This does not make bit fields useless. It means they are context-sensitive and not a reliable way to control precise bit-level memory layout.

Appropriate Uses of Bit Fields

Bit fields and manual bit masking serve different purposes, even though both operate at the bit level.

Bit fields are best used to represent logical state inside your program. They improve readability, group related flags naturally, and work well when the exact memory layout does not matter outside the program. This makes them a good fit for internal flags, state machines, and configuration structures.

Manual bit masking is the correct choice when exact bit positions matter. This includes hardware registers, binary protocols, and any layout defined by a datasheet or specification. Bit masks provide full control over bit positions, behave consistently across compilers, and match hardware documentation exactly.

For example, when working with hardware registers:

#define UART_RXNE (1 << 5)
#define UART_TC   (1 << 6)
#define UART_TXE  (1 << 7)

This approach may look less elegant than bit fields, but it is precise, portable, and unambiguous. In embedded systems, correctness matters more than elegance.

While bool works for individual flags, multiple bool members still consume at least one byte each and may introduce padding.

Rules of Thumb

Bit fields express meaning, not layout.
Never use bit fields for memory-mapped hardware registers.
Use bit fields for internal flags and logical program state.
Use bit masks for hardware registers and binary protocols.

DEV Community