C Programming – How to use bit fields in structures?

Structures in C are used to group multiple variables of same or different types. The variables inside the structures can be accessible through it’s structure variables. I recommend you to read the article, “C Programming – Understanding Structures in C“, before proceeding with this.

Usually, ‘C’ structures are to group related information.

‘C’ compiler allocates memory for each variable mentioned in the structures. The size of the memory ‘C’ allocates is depends on the type of the variable. We can inform ‘C’ compiler 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 we 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 to 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 (usually); 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.

Let’s 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, we have 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, the code displays 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, each bit value is assigned 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

Add a Comment

Your email address will not be published.