C Programming: How to use bit fields in structures?

‘C’ structures are used to group multiple variables of same or different types. The variables inside the structures can be accessible through its structure variable.

‘C’ structures are useful to maintain related information.

‘C’ allocates memory for each variable mentioned in structures. The size of the memory ‘C’ allocates is depends on the type of the variable. We can inform ‘C’ to allocate the size of the memory for each variable by using bit fields.

The least memory size allocated for a variable is one byte (1 Byte). But how do you allocate a memory of only one bit (1 bit) for a variable? It is possible through bit fields.

Below is the syntax to define bit fields in ‘C’ structures.

struct <structure name>
{
   <data type 1> <variable name 1> : <width>;
   ...
   <data type N> <variable name N> : <width>;
};

Above structure declaration is almost same as the normal structure declaration; except that <width> field. <width> field indicates the number of bits allocate to the variable.

There is a condition when specifying the <width> field. The number of bits mentioned in the <width> field must be less than or equals to the maximum number of bits allowed to the data type of the variable. For example: if the data type of the variable is “int” and maximum allowed bits for this type is 32 bits; in <width> field we should specify the value less than or equals to 32. If we provide the value greater than 32 as the <width> value, ‘C’ compiler will throw the below error.

error: width of ‘var’ exceeds its type

Bit fields are mainly useful in low-level programming.

Lets take a simple example to understand how to deal with bit fields in ‘C’ structures.

// Sample.c
#include <stdio.h>

struct Byte
{
   unsigned char bit1 : 1;
   unsigned char bit2 : 1;
   unsigned char bit3 : 1;
   unsigned char bit4 : 1;
   unsigned char bit5 : 1;
   unsigned char bit6 : 1;
   unsigned char bit7 : 1;
   unsigned char bit8 : 1;
};

void main()
{
   printf("\nunsigned char: %d Byte(s)", sizeof(unsigned char));
   printf("\nByte: %d Byte(s)", sizeof(struct Byte));

   struct Byte byte = {0, 1, 0, 0, 0, 0, 0, 0};

   printf("\nByte Value: %d", byte);
}

From above code, I have created a Byte structure with “unsigned char” variables and only “1 bit” is allotted for each variable. Purpose of this Byte structure is to store and retrieve each bit’s value in an “unsigned char” variable.

After that I have displayed the size of Byte structure; on my system, it displayed as “1 Byte” of size. So, if we declare a normal structure, it will display as “8 Byte(s)” of size for the same structure; we saved the memory by using bit fields.

Once the structure is declared, I have assigned each bit value and display the result. Now we have the flexibility to access each bit in an “unsigned char” value.

I have compiled and executed this program on my CentOS 64-bit Operating System and I got the below result.

unsigned char: 1 Byte(s)
Byte: 1 Byte(s)
Value is: 2

// Malin

Leave a Reply