Bit field

A pre-determined size is allocated for members in structs and classes.

class A{
    int a; //size of int is usually 4 bytes
}

For integral primitive data types (such as int, long, and char), the allocated size can be modified using a bit field.

With bit fields only a specific number of bits within the allocated size is used.

Bit field Syntax

A bit field can be defined only for members within a structure or class.

• A bit field cannot be defined for standalone variables, this is not possible: int main() {int a:3 =5;}.

The number of allocated bits (width) is specified after a colon next to the member name.

Bit field Syntax in Struct

struct StructName {
    dataType fieldName : width;
    // more bit-field members...
};

Bit field Syntax in Classes

class ClassName {
public:
    dataType fieldName : width;
    // more bit-field members...
};

Example

struct MyStruct {
    unsigned int a : 3;  // 3 bits for a
    unsigned int b : 5;  // 5 bits for b
    unsigned int c : 4;  // 4 bits for c
};

In this example, the MyStruct structure contains three members, where:

• a uses 3 bits
• b uses 5 bits
• c uses 4 bits

This partitioning allows memory to be saved since a, b, and c are stored within 12 bits (3 + 5 + 4). Typically, the structure will take up 4 bytes (32 bits) in memory because the compiler rounds it to the base size of the type.

Interesting facts

The number of bits allocated to a member variable can be greater than the default size of its data type.

Advantages

Memory Efficiency

Values are stored in smaller units than a full data type. For example, instead of using an int for values that require no more than 5 bits, you can use a bit field with 5 bits.

Efficient Data Storage

Bit fields are ideal for cases where you have many small values, like flag settings that occupy only 1 or 2 bits.

Disadvantages and limitations

Portability Issues across different platforms

Bit field layout and padding and the overall size of the structure depends on the compiler and platform.

No Typecasting

Bit fields are typically limited to one base data type, meaning you cannot typecast them to another type, such as from unsigned int to bool.

Read and Write Restrictions

When working with bit fields, it's important to avoid reading or writing values that exceed the allowed bit count, as this could lead to undefined or unpredictable results.

No addressability

The address of a bit field cannot be referenced.

Reason: they might not start at a byte boundary.

Flags f;
unsigned int* ptr = &f.flag1;  // Error!

Performance overhead

Accessing bit fields may generate extra instructions due to masking and shifting.

Less readable code

Bit fields can make code less readable.

Alternative: Bit Manipulation with Masks

When precise control is needed, direct bitwise operations are often preferred:

# define FLAG1 (1 << 0)
# define FLAG2 (1 << 1)
# define FLAG3 (1 << 2)

unsigned int flags = 0; 
flags |= FLAG1; // Set flag1 
if (flags & FLAG2) { /* Check flag2 */ } 
flags &= ~FLAG3; // Clear flag3 
<pre>

== Example of Using a Bit Field ==
<pre>
#include <iostream>

struct Flags {
    unsigned int is_visible : 1;  // 1 bit for visibility flag
    unsigned int is_active : 1;   // 1 bit for active flag
    unsigned int priority : 3;    // 3 bits for priority
};

int main() {
    Flags myFlags = {1, 0, 5};  // is_visible = 1, is_active = 0, priority = 5

    std::cout << "is_visible: " << myFlags.is_visible << std::endl;
    std::cout << "is_active: " << myFlags.is_active << std::endl;
    std::cout << "priority: " << myFlags.priority << std::endl;

    return 0;
}

This example shows how to define bit fields within a structure and assign values to individual bit fields. The output of the program will be:

Conclusion

Bit fields are useful for memory-efficient structures, especially in embedded systems, hardware interfacing, and low-level programming. However, they come with limitations such as undefined layout across different compilers and inability to take addresses of bit fields. In cases where flexibility is needed, manual bitwise operations using masks may be a better choice.