Bit Fields

#include <stdio.h>

/* Structure without bit fields */
struct FlagsNormal {
    int flag1;  /* 4 bytes */
    int flag2;  /* 4 bytes */
    int flag3;  /* 4 bytes */
};  /* Total: 12 bytes */

/* Structure with bit fields */
struct FlagsBitfield {
    unsigned int flag1 : 1;  /* 1 bit */
    unsigned int flag2 : 1;  /* 1 bit */
    unsigned int flag3 : 1;  /* 1 bit */
};  /* Total: 4 bytes (or less) */

int main(void) {
    printf("Normal flags: %zu bytes\n", sizeof(struct FlagsNormal));      /* 12 */
    printf("Bitfield flags: %zu bytes\n", sizeof(struct FlagsBitfield));  /* 4 */
    
    struct FlagsBitfield flags = {0};
    flags.flag1 = 1;
    flags.flag2 = 0;
    flags.flag3 = 1;
    
    printf("flag1: %u, flag2: %u, flag3: %u\n",
           flags.flag1, flags.flag2, flags.flag3);
    
    return 0;
}

/* Memory layout (conceptual):
   Without bit fields:
   ┌────┬────┬────┐
   │ 4B │ 4B │ 4B │  = 12 bytes
   └────┴────┴────┘
   
   With bit fields:
   ┌───────────────┐
   │ f1|f2|f3| ... │  = 4 bytes
   └───────────────┘

/* Basic bit field syntax */
struct BitFieldExample {
    unsigned int field1 : 3;  /* 3 bits (values 0-7) */
    unsigned int field2 : 5;  /* 5 bits (values 0-31) */
    unsigned int field3 : 8;  /* 8 bits (values 0-255) */
};

/* Signed vs unsigned */
struct SignedBitFields {
    signed int s_field : 4;    /* -8 to 7 */
    unsigned int u_field : 4;  /* 0 to 15 */
};

void test_signed_unsigned(void) {
    struct SignedBitFields bf = {0};
    
    bf.s_field = 7;   /* OK: within range */
    bf.s_field = 8;   /* Overflow: becomes -8 */
    bf.u_field = 15;  /* OK: within range */
    
    printf("Signed: %d, Unsigned: %u\n", bf.s_field, bf.u_field);
}

/* Zero-width bit field (forces alignment) */
struct WithPadding {
    unsigned int field1 : 3;
    unsigned int : 0;          /* Force next field to new storage unit */
    unsigned int field2 : 3;
};

/* Anonymous bit fields for padding */
struct WithUnnamedPadding {
    unsigned int field1 : 3;
    unsigned int : 5;          /* 5 bits of padding */
    unsigned int field2 : 3;
};

/* Rules and limitations */
/*
   1. Can't take address of bit field
      &bf.field1;  // ERROR
   
   2. Can't create array of bit fields
      struct {
          unsigned int bits[10] : 1;  // ERROR
      };
   
   3. Can't use sizeof on bit field
      sizeof(bf.field1);  // ERROR
   
   4. Bit field width must fit in type
      unsigned int too_wide : 64;  // ERROR if int is 32 bits
   
   5. Implementation-defined padding and ordering
   
   6. Can mix bit fields with regular members
*/

struct Mixed {
    unsigned int bits : 4;  /* Bit field */
    int regular;            /* Regular member */
    unsigned int more : 2;  /* Bit field */
};

/* Maximum widths */
struct MaxWidths {
    unsigned int max_uint : 32;   /* Full unsigned int */
    signed int max_sint : 31;     /* Max for signed (1 bit for sign) */
};

/* Hardware register mapping */
typedef struct {
    unsigned int enable : 1;
    unsigned int mode : 2;
    unsigned int speed : 3;
    unsigned int reserved1 : 2;
    unsigned int interrupt_enable : 1;
    unsigned int reserved2 : 7;
    unsigned int error_flag : 1;
    unsigned int busy_flag : 1;
    unsigned int reserved3 : 14;
} HardwareRegister;

void configure_hardware(volatile HardwareRegister *reg) {
    reg->enable = 1;
    reg->mode = 2;           /* Mode 2 */
    reg->speed = 5;          /* Speed level 5 */
    reg->interrupt_enable = 1;
}

/* TCP flags */
struct TCPFlags {
    unsigned int fin : 1;
    unsigned int syn : 1;
    unsigned int rst : 1;
    unsigned int psh : 1;
    unsigned int ack : 1;
    unsigned int urg : 1;
    unsigned int ece : 1;
    unsigned int cwr : 1;
};

void print_tcp_flags(struct TCPFlags flags) {
    printf("FIN=%u SYN=%u RST=%u PSH=%u ACK=%u URG=%u ECE=%u CWR=%u\n",
           flags.fin, flags.syn, flags.rst, flags.psh,
           flags.ack, flags.urg, flags.ece, flags.cwr);
}

/* File permissions (Unix-style) */
struct FilePermissions {
    unsigned int owner_read : 1;
    unsigned int owner_write : 1;
    unsigned int owner_execute : 1;
    unsigned int group_read : 1;
    unsigned int group_write : 1;
    unsigned int group_execute : 1;
    unsigned int other_read : 1;
    unsigned int other_write : 1;
    unsigned int other_execute : 1;
};

int permissions_to_octal(struct FilePermissions perms) {
    int owner = (perms.owner_read << 2) | (perms.owner_write << 1) | perms.owner_execute;
    int group = (perms.group_read << 2) | (perms.group_write << 1) | perms.group_execute;
    int other = (perms.other_read << 2) | (perms.other_write << 1) | perms.other_execute;
    
    return (owner << 6) | (group << 3) | other;
}

/* Graphics pixel format */
struct RGB565 {
    unsigned int blue : 5;   /* 5 bits for blue */
    unsigned int green : 6;  /* 6 bits for green */
    unsigned int red : 5;    /* 5 bits for red */
};  /* Total: 16 bits (2 bytes) */

struct RGB565 create_color(unsigned char r, unsigned char g, unsigned char b) {
    struct RGB565 color;
    color.red = r >> 3;    /* Convert 8-bit to 5-bit */
    color.green = g >> 2;  /* Convert 8-bit to 6-bit */
    color.blue = b >> 3;   /* Convert 8-bit to 5-bit */
    return color;
}

/* Date packing */
struct PackedDate {
    unsigned int day : 5;     /* 1-31 */
    unsigned int month : 4;   /* 1-12 */
    unsigned int year : 12;   /* 0-4095 (years since base) */
};  /* Total: 21 bits (fits in 3 bytes + padding) */

struct PackedDate pack_date(int day, int month, int year) {
    struct PackedDate date;
    date.day = day;
    date.month = month;
    date.year = year - 2000;  /* Store years since 2000 */
    return date;
}

/* Status register */
typedef struct {
    unsigned int ready : 1;
    unsigned int error : 1;
    unsigned int busy : 1;
    unsigned int mode : 3;
    unsigned int priority : 2;
    unsigned int reserved : 24;
} StatusRegister;

int is_ready(StatusRegister status) {
    return status.ready && !status.busy && !status.error;
}

/* Bit fields with union for dual access */
typedef union {
    struct {
        unsigned int bit0 : 1;
        unsigned int bit1 : 1;
        unsigned int bit2 : 1;
        unsigned int bit3 : 1;
        unsigned int bit4 : 1;
        unsigned int bit5 : 1;
        unsigned int bit6 : 1;
        unsigned int bit7 : 1;
    } bits;
    unsigned char byte;
} ByteBits;

void manipulate_bits(void) {
    ByteBits bb;
    
    /* Set individual bits */
    bb.bits.bit0 = 1;
    bb.bits.bit3 = 1;
    bb.bits.bit7 = 1;
    
    /* Access as byte */
    printf("Byte value: 0x%02X\n", bb.byte);  /* 0x89 */
    
    /* Set entire byte */
    bb.byte = 0xFF;
    
    /* Check individual bits */
    printf("bit0: %u, bit7: %u\n", bb.bits.bit0, bb.bits.bit7);
}

/* 32-bit register with field and raw access */
typedef union {
    struct {
        unsigned int enable : 1;
        unsigned int mode : 3;
        unsigned int channel : 4;
        unsigned int priority : 2;
        unsigned int reserved : 6;
        unsigned int interrupt : 1;
        unsigned int dma : 1;
        unsigned int reserved2 : 14;
    } fields;
    unsigned int raw;
} ConfigRegister;

void configure_register(volatile ConfigRegister *reg, unsigned int value) {
    /* Can write entire register */
    reg->raw = value;
    
    /* Or modify individual fields */
    reg->fields.enable = 1;
    reg->fields.mode = 3;
    reg->fields.channel = 7;
}

/* Network packet header */
typedef union {
    struct {
        unsigned char version : 4;
        unsigned char ihl : 4;
        unsigned char tos;
        unsigned short total_length;
        unsigned short identification;
        unsigned short flags_fragment : 16;
        unsigned char ttl;
        unsigned char protocol;
        unsigned short checksum;
        unsigned int source_ip;
        unsigned int dest_ip;
    } header;
    unsigned char raw[20];
} IPHeader;

void parse_ip_packet(const unsigned char *packet) {
    IPHeader ip;
    memcpy(ip.raw, packet, sizeof(ip.raw));
    
    printf("Version: %u\n", ip.header.version);
    printf("IHL: %u\n", ip.header.ihl);
    printf("Protocol: %u\n", ip.header.protocol);
}

/* Color with bit field and integer access */
typedef union {
    struct {
        unsigned char b : 5;
        unsigned char g : 6;
        unsigned char r : 5;
    } rgb;
    unsigned short value;
} Color16;

Color16 blend_colors(Color16 c1, Color16 c2) {
    Color16 result;
    result.rgb.r = (c1.rgb.r + c2.rgb.r) / 2;
    result.rgb.g = (c1.rgb.g + c2.rgb.g) / 2;
    result.rgb.b = (c1.rgb.b + c2.rgb.b) / 2;
    return result;
}

/* Issue 1: Bit order is implementation-defined */
struct BitOrder {
    unsigned int a : 4;
    unsigned int b : 4;
};

/* On some systems: [aaaa][bbbb]
   On others:       [bbbb][aaaa] */

/* Issue 2: Alignment and padding */
struct AlignmentIssue {
    unsigned int a : 3;
    unsigned int b : 10;  /* May or may not cross byte boundary */
};

/* Different compilers may produce different layouts */

/* Issue 3: Signedness of plain int */
struct SignednessIssue {
    int field : 3;  /* Signed or unsigned? Implementation-defined */
};

/* Better: Be explicit */
struct ExplicitSign {
    signed int s_field : 3;    /* Definitely signed */
    unsigned int u_field : 3;  /* Definitely unsigned */
};

/* Portable alternatives */

/* Option 1: Use explicit bit manipulation */
typedef struct {
    unsigned int value;
} PortableFlags;

#define FLAG_BIT0  (1U << 0)
#define FLAG_BIT1  (1U << 1)
#define FLAG_BIT2  (1U << 2)

void set_flag(PortableFlags *flags, unsigned int flag) {
    flags-&gt;value |= flag;
}

void clear_flag(PortableFlags *flags, unsigned int flag) {
    flags-&gt;value &= ~flag;
}

int test_flag(const PortableFlags *flags, unsigned int flag) {
    return (flags-&gt;value & flag) != 0;
}

/* Option 2: Use bitwise macros */
#define GET_BITS(value, mask, shift)  (((value) & (mask)) >> (shift))
#define SET_BITS(value, bits, mask, shift) \
    ((value) = ((value) & ~(mask)) | (((bits) << (shift)) & (mask)))

typedef struct {
    unsigned int reg;
} Register;

#define MODE_MASK   0x0000000E
#define MODE_SHIFT  1
#define ENABLE_MASK 0x00000001
#define ENABLE_SHIFT 0

unsigned int get_mode(Register reg) {
    return GET_BITS(reg.reg, MODE_MASK, MODE_SHIFT);
}

void set_mode(Register *reg, unsigned int mode) {
    SET_BITS(reg-&gt;reg, mode, MODE_MASK, MODE_SHIFT);
}

/* Option 3: Document platform assumptions */
/*
 * This bit field layout assumes:
 * - Little-endian system
 * - GCC or Clang compiler
 * - No padding between fields < 32 bits
 * 
 * VERIFY on target platform before use!
 */
struct PlatformSpecific {
    unsigned int field1 : 8;
    unsigned int field2 : 8;
    unsigned int field3 : 16;
} __attribute__((packed));  /* GCC-specific */

/* Best practices for portable bit fields */
/*
   1. Use only for platform-specific code
   2. Test on all target platforms
   3. Document bit order assumptions
   4. Use explicit signed/unsigned
   5. Avoid bit fields in cross-platform protocols
   6. Consider explicit bit manipulation instead
   7. Use static_assert to verify sizes (C11)
*/

#ifdef __STDC_VERSION__
#if __STDC_VERSION__ >= 201112L
_Static_assert(sizeof(struct BitOrder) == 1, "BitOrder must be 1 byte");
#endif
#endif

/* Approach 1: Bit fields (cleaner syntax) */
struct BitFieldFlags {
    unsigned int read : 1;
    unsigned int write : 1;
    unsigned int execute : 1;
    unsigned int reserved : 29;
};

void bf_set_flags(struct BitFieldFlags *flags) {
    flags->read = 1;
    flags->write = 1;
    flags->execute = 0;
}

int bf_can_read(struct BitFieldFlags flags) {
    return flags.read;
}

/* Approach 2: Manual bit manipulation (more portable) */
typedef unsigned int ManualFlags;

#define FLAG_READ    (1U << 0)
#define FLAG_WRITE   (1U << 1)
#define FLAG_EXECUTE (1U << 2)

void manual_set_flags(ManualFlags *flags) {
    *flags = FLAG_READ | FLAG_WRITE;
}

int manual_can_read(ManualFlags flags) {
    return (flags & FLAG_READ) != 0;
}

void manual_toggle_flag(ManualFlags *flags, ManualFlags flag) {
    *flags ^= flag;
}

void manual_clear_flag(ManualFlags *flags, ManualFlags flag) {
    *flags &= ~flag;
}

/* Comparison */
void compare_approaches(void) {
    /* Bit field approach */
    struct BitFieldFlags bf = {0};
    bf.read = 1;
    bf.write = 1;
    if (bf.read) {
        printf("Can read\n");
    }
    
    /* Manual approach */
    ManualFlags mf = 0;
    mf |= FLAG_READ | FLAG_WRITE;
    if (mf & FLAG_READ) {
        printf("Can read\n");
    }
}

/* When to use each */
/*
   Use bit fields when:
   - Working with hardware registers (platform-specific)
   - Code readability is priority
   - Target platform is fixed
   - Memory efficiency is critical
   
   Use manual manipulation when:
   - Need portable code
   - Working with protocols/file formats
   - Need predictable bit layout
   - Performance is critical
   - Need bitwise operations (AND, OR, XOR)
*/