Bit Fields in C

A bit field in C allows structure members to use a specific number of bits instead of the full size of their data type, helping to save memory.

• Reduces memory usage by allocating only the required number of bits.
• Commonly used in embedded systems and hardware programming where memory is limited.

#include <stdio.h>

struct DeviceStatus {
    unsigned int power : 1;
    unsigned int wifi : 1;
    unsigned int bluetooth : 1;
};

int main(){
    struct DeviceStatus device;

    device.power = 1;
    device.wifi = 0;
    device.bluetooth = 1;

    printf("Power: %u\n", device.power);
    printf("WiFi: %u\n", device.wifi);
    printf("Bluetooth: %u\n", device.bluetooth);

    return 0;
}

Power: 1
WiFi: 0
Bluetooth: 1

Explanation

• The power, wifi, and bluetooth members use only 1 bit each.
• This saves memory compared to storing each value as a normal integer.
• Bit fields are useful for storing flags and Boolean values efficiently.

Declaration of C Bit Fields

Bit-fields are variables that are defined using a predefined width or size. Format and the declaration of the bit-fields in C are shown below:

Syntax

struct {

data_type member_name : width_of_bit-field;

};

where,

• data_type: Specifies the integer type of the bit field, such as int, signed int, or unsigned int.
• member_name: Represents the name of the bit-field member.
• width: Defines the number of bits allocated to the member and must not exceed the size of the specified data type.

To learn more about how to use bit fields in data structures and optimize memory usage, the C Programming Course Online with Data Structures provides comprehensive lessons on bitwise operations and memory management.

Applications of C Bit Fields

Bit fields are commonly used in situations where memory optimization is important.

• When available storage is limited.
• In embedded systems for representing hardware registers.
• In communication protocols where multiple status flags are packed into a single byte or word.
• When devices transmit status or information encoded into multiple bits.
• In encryption and compression algorithms that require bit-level manipulation.
• For storing multiple Boolean values efficiently.

Example of C Bit Fields

In this example, we compare the size difference between the structure that does not specify bit fields and the structure that has specified bit fields.

Structure Without Bit Fields

Consider the following declaration of date without the use of bit fields.

#include <stdio.h>

// A simple representation of the date
struct date {
    unsigned int d;
    unsigned int m;
    unsigned int y;
};

int main()
{
    // printing size of structure
    printf("Size of date is %lu bytes\n",
           sizeof(struct date));
    struct date dt = { 31, 12, 2014 };
    printf("Date is %d/%d/%d", dt.d, dt.m, dt.y);
}

Size of date is 12 bytes
Date is 31/12/2014

• A normal structure allocates the full size of each member, which can result in unnecessary memory usage.
• Since fields like day and month have a limited range of values, bit fields can be used to store them more efficiently and reduce the overall memory required.

Structure with Bit Field

The below code defines a structure named date with a single member month. The month member is declared as a bit field with 4 bits.

struct date{

// month has value between 0 and 15,
// so 4 bits are sufficient for month variable.
int month : 4;
};

However, if the same code is written using signed int and the value of the fields goes beyond the bits allocated to the variable, something interesting can happen.

Below is the same code but with signed integers:

// C program to demonstrate use of Bit-fields
#include <stdio.h>

// Space optimized representation of the date
struct date {
    // d has value between 0 and 31, so 5 bits
    // are sufficient
    int d : 5;

    // m has value between 0 and 15, so 4 bits
    // are sufficient
    int m : 4;

    int y;
};

int main()
{
    printf("Size of date is %lu bytes\n",
           sizeof(struct date));
    struct date dt = { 31, 12, 2014 };
    printf("Date is %d/%d/%d", dt.d, dt.m, dt.y);
    return 0;
}

Size of date is 8 bytes
Date is -1/-4/2014

Explanation

• Storing values like 31 in a signed 5-bit bit field causes the most significant bit (MSB) to become 1, so the value is interpreted as negative.
• The compiler uses 2's complement representation to determine the actual signed value, resulting in outputs like -1 instead of 31.
• Similarly, storing 12 in a signed 4-bit bit field is interpreted as -4 due to the limited bit size.

Advantages of C Bit Fields

• Reduces memory consumption.
• Efficient for storing flags and status values.
• Improves memory utilization in embedded systems.
• Useful for hardware register mapping.

Limitations of C Bit Fields

• Supported only with integer data types.
• The memory layout of bit fields is compiler-dependent.
• Individual bit-field members cannot have their addresses taken.
• Bit-field behavior may vary across different platforms and compilers.