C Bit Fields

Bit Field Features

struct Compact {
    unsigned int a : 4;  // 4 bits
};

unsigned int value : 5;  // 5 bits
// Range: 0 to 31

struct Register {
    unsigned int enable : 1;
    unsigned int mode : 2;
};

// Multiple flags in one byte
struct Status {
    unsigned int ready : 1;
    unsigned int error : 1;
};

🔹 Basic Bit Field Example

Bit fields in C allow you to store data in a compact format by specifying the exact number of bits needed for each member. The struct keyword is used to define bit fields, where you declare an integer type followed by a colon and the number of bits. For example, unsigned int flag : 1; creates a single-bit flag that can hold 0 or 1. This technique is particularly useful when memory optimization is critical, such as in embedded systems programming. Bit fields help reduce memory consumption by packing multiple small values into a single storage unit, making your programs more efficient and memory-friendly for resource-constrained environments.

#include <stdio.h>

struct Flags {
    unsigned int flag1 : 1;   // 1 bit (0 or 1)
    unsigned int flag2 : 1;   // 1 bit (0 or 1)
    unsigned int counter : 4; // 4 bits (0 to 15)
    unsigned int mode : 2;    // 2 bits (0 to 3)
};

int main() {
    struct Flags f = {0};
    
    printf("Size of struct Flags: %lu bytes\n", sizeof(f));
    
    // Set bit field values
    f.flag1 = 1;
    f.flag2 = 0;
    f.counter = 12;  // Binary: 1100
    f.mode = 3;      // Binary: 11
    
    printf("\nBit field values:\n");
    printf("flag1: %u\n", f.flag1);
    printf("flag2: %u\n", f.flag2);
    printf("counter: %u\n", f.counter);
    printf("mode: %u\n", f.mode);
    
    // Modify values
    f.counter++;
    if (f.counter > 15) {  // Counter overflow
        f.counter = 0;
        f.flag2 = 1;  // Set overflow flag
    }
    
    printf("\nAfter increment:\n");
    printf("counter: %u\n", f.counter);
    printf("flag2 (overflow): %u\n", f.flag2);
    
    return 0;
}

Size of struct Flags: 4 bytes

Bit field values:
flag1: 1
flag2: 0
counter: 12
mode: 3

After increment:
counter: 13
flag2 (overflow): 0

🔹 Date Storage with Bit Fields

Storing dates using bit fields provides an efficient way to represent day, month, and year information in minimal memory space. You can create a struct Date with members like unsigned int day : 5; for days (1-31 requiring 5 bits), unsigned int month : 4; for months (1-12 requiring 4 bits), and unsigned int year : 12; for years. This structure uses only 21 bits total instead of potentially 96 bits if using three separate integers. The compact representation is ideal for applications that store large numbers of dates, such as calendars, scheduling systems, or databases where memory efficiency directly impacts performance and scalability.

#include <stdio.h>

struct Date {
    unsigned int day : 5;    // 5 bits (1-31)
    unsigned int month : 4;  // 4 bits (1-12)
    unsigned int year : 12;  // 12 bits (0-4095)
};

void printDate(struct Date d) {
    const char* months[] = {
        "", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    };
    
    printf("%02d-%s-%04d", d.day, months[d.month], d.year + 1900);
}

int main() {
    struct Date today = {25, 12, 123};  // 25-Dec-2023 (123 + 1900)
    struct Date birthday = {15, 6, 95}; // 15-Jun-1995 (95 + 1900)
    
    printf("Size of Date structure: %lu bytes\n", sizeof(struct Date));
    printf("Normal int size: %lu bytes\n", sizeof(int) * 3);
    
    printf("\nToday's date: ");
    printDate(today);
    printf("\n");
    
    printf("Birthday: ");
    printDate(birthday);
    printf("\n");
    
    // Validate ranges
    printf("\nRange validation:\n");
    printf("Day range: 1 to %u\n", (1 << 5) - 1);    // 2^5 - 1 = 31
    printf("Month range: 1 to %u\n", (1 << 4) - 1);  // 2^4 - 1 = 15
    printf("Year range: 0 to %u\n", (1 << 12) - 1);  // 2^12 - 1 = 4095
    
    return 0;
}

Size of Date structure: 4 bytes
Normal int size: 12 bytes

Today's date: 25-Dec-2023

Birthday: 15-Jun-1995

Range validation:
Day range: 1 to 31
Month range: 1 to 15
Year range: 0 to 4095

🔹 Hardware Register Simulation

Bit fields are extensively used to simulate hardware control registers in embedded systems and device driver programming. Hardware registers often have multiple control flags and settings packed into a single memory location, and bit fields provide a clean way to access them. For example, you can define a struct ControlRegister with bit fields for enable flags, mode settings, and status indicators that directly map to hardware specifications. Using bit fields makes the code more readable than manual bit masking with operations like &, |, and shift operators, while maintaining the same low-level control needed for hardware interfacing and system programming tasks.

#include <stdio.h>

struct ControlRegister {
    unsigned int enable : 1;      // Enable bit
    unsigned int mode : 3;        // Operation mode (0-7)
    unsigned int priority : 2;    // Priority level (0-3)
    unsigned int reserved : 2;    // Reserved bits
    unsigned int interrupt : 1;   // Interrupt enable
    unsigned int status : 7;      // Status bits
};

void printRegister(struct ControlRegister reg) {
    printf("Control Register Status:\n");
    printf("========================\n");
    printf("Enable: %s\n", reg.enable ? "ON" : "OFF");
    printf("Mode: %u\n", reg.mode);
    printf("Priority: %u\n", reg.priority);
    printf("Interrupt: %s\n", reg.interrupt ? "ENABLED" : "DISABLED");
    printf("Status: 0x%02X\n", reg.status);
    printf("Reserved: %u\n", reg.reserved);
}

int main() {
    struct ControlRegister ctrl = {0};
    
    printf("Size of control register: %lu bytes\n\n", sizeof(ctrl));
    
    // Configure the register
    ctrl.enable = 1;
    ctrl.mode = 5;        // Mode 5
    ctrl.priority = 2;    // High priority
    ctrl.interrupt = 1;   // Enable interrupts
    ctrl.status = 0x42;   // Status code
    ctrl.reserved = 0;    // Reserved bits
    
    printRegister(ctrl);
    
    // Simulate status change
    printf("\nSimulating error condition...\n");
    ctrl.status |= 0x80;  // Set error bit (bit 7)
    ctrl.enable = 0;      // Disable on error
    
    printRegister(ctrl);
    
    // Check specific bits
    printf("\nBit analysis:\n");
    printf("Error bit (bit 7): %s\n", 
           (ctrl.status & 0x80) ? "SET" : "CLEAR");
    printf("Ready bit (bit 1): %s\n", 
           (ctrl.status & 0x02) ? "SET" : "CLEAR");
    
    return 0;
}

Size of control register: 4 bytes

Control Register Status:
========================
Enable: ON
Mode: 5
Priority: 2
Interrupt: ENABLED
Status: 0x42
Reserved: 0

Simulating error condition...
Control Register Status:
========================
Enable: OFF
Mode: 5
Priority: 2
Interrupt: ENABLED
Status: 0xC2
Reserved: 0

Bit analysis:
Error bit (bit 7): SET
Ready bit (bit 1): SET

🔹 Bit Field Limitations

Understanding bit field constraints is crucial for writing reliable and portable C code, as they have several important limitations. Bit fields cannot have their address taken with the & operator because they may not start on byte boundaries. The ordering of bit fields within a byte is implementation-defined, meaning different compilers may arrange them differently. You cannot create arrays of bit fields, and their portability across different platforms can be problematic due to varying byte ordering (endianness) and alignment rules. Additionally, bit fields can only be declared as int, signed int, unsigned int, or _Bool types, limiting their flexibility in certain programming scenarios.

#include <stdio.h>

struct BitFieldDemo {
    unsigned int small : 3;   // 3 bits: range 0-7
    signed int negative : 4;  // 4 bits signed: range -8 to 7
    unsigned int large : 10;  // 10 bits: range 0-1023
};

int main() {
    struct BitFieldDemo demo = {0};
    
    printf("Bit Field Limitations Demo:\n");
    printf("===========================\n");
    
    // Test small field overflow
    demo.small = 7;  // Maximum value for 3 bits
    printf("small = %u (max for 3 bits)\n", demo.small);
    
    demo.small = 8;  // Overflow! Will wrap to 0
    printf("small = %u (after overflow)\n", demo.small);
    
    // Test signed bit field
    demo.negative = 7;   // Maximum positive
    printf("negative = %d (max positive)\n", demo.negative);
    
    demo.negative = -8;  // Maximum negative
    printf("negative = %d (max negative)\n", demo.negative);
    
    demo.negative = 8;   // Overflow in signed field
    printf("negative = %d (after positive overflow)\n", demo.negative);
    
    // Test large field
    demo.large = 1023;  // Maximum for 10 bits
    printf("large = %u (max for 10 bits)\n", demo.large);
    
    demo.large = 1024;  // Overflow
    printf("large = %u (after overflow)\n", demo.large);
    
    printf("\nImportant Notes:\n");
    printf("- Bit fields cannot have addresses (& operator)\n");
    printf("- Arrays of bit fields are not allowed\n");
    printf("- Bit field order is implementation-dependent\n");
    printf("- Use unsigned for most bit fields\n");
    
    return 0;
}

Bit Field Limitations Demo:
===========================
small = 7 (max for 3 bits)
small = 0 (after overflow)
negative = 7 (max positive)
negative = -8 (max negative)
negative = -8 (after positive overflow)
large = 1023 (max for 10 bits)
large = 0 (after overflow)

Important Notes:
- Bit fields cannot have addresses (& operator)
- Arrays of bit fields are not allowed
- Bit field order is implementation-dependent
- Use unsigned for most bit fields