When we declare a struct or a union type, the size of the struct/union type variable depends on the individual size of its elements. Instead of the default memory size, you can set the size the bits to restrict the size. The specified size is called bit fields.

This is the syntax you would use to declare a bit field −

struct {
   data_type elem : width;
};

Let”s suppose your C program contains a number of TRUE/FALSE variables grouped in a structure called status, as follows −

struct {
   unsigned int widthValidated;
   unsigned int heightValidated;
} status;

This structure requires 8 bytes of memory space but in actual, we are going to store either “0” or “1” in each of the variables. The C programming language offers a better way to utilize the memory space in such situations.

If you are using such variables inside a structure, then you can define the width of the variables which tells the C compiler that you are going to use only those many number of bytes. For example, the above structure can be re-written as follows −

struct {
   unsigned int widthValidated : 1;
   unsigned int heightValidated : 1;
} status;

The above structure requires 4 bytes of memory space for the status variable, but only 2 bits will be used to store the values.

Example

If you will use up to 32 variables, each one with a width of 1 bit, then also the status structure will use 4 bytes. However, as soon as you have 33 variables, it will allocate the next slot of the memory and it will start using 8 bytes.

Let us check the following example to understand the concept −

#include <stdio.h>

/* define simple structure */
struct {
   unsigned int widthValidated;
   unsigned int heightValidated;
} status1;

/* define a structure with bit fields */
struct {
   unsigned int widthValidated : 1;
   unsigned int heightValidated : 1;
} status2;

int main() {

   printf("Memory size occupied by status1: %dn", sizeof(status1));
   printf("Memory size occupied by status2: %dn", sizeof(status2));
   
   return 0;
}

Output

When the above code is compiled and executed, it produces the following Output −

Memory size occupied by status1: 8
Memory size occupied by status2: 4

Bit Field Declaration

The declaration of a bit-field has the following form inside a structure −

struct {
   type [member_name] : width ;
};

The following table describes the variable elements of a bit field −

The variables defined with a predefined width are called bit fields. A bit field can hold more than a single bit; for example, if you need a variable to store a value from 0 to 7, then you can define a bit field with a width of 3 bits, as follows −

struct {
   unsigned int age : 3;
} Age;

The above structure definition instructs the C compiler that the variable “Age” is going to use only 3 bits to store the value. If you try to use more than 3 bits, then it will not allow you to do so.

Example

Let us try the following example −

#include <stdio.h>

struct {
   unsigned int age : 3;
} Age;

int main() {

   Age.age = 4;
   printf("Sizeof(Age): %dn", sizeof(Age));
   printf("Age.age: %dn", Age.age);

   Age.age = 7;
   printf("Age.age : %dn", Age.age);

   Age.age = 8;
   printf("Age.age : %dn", Age.age);

   return 0;
}

Output

When the above code is compiled, it will compile with a warning −

warning: unsigned conversion from ''int'' to ''unsigned char:3'' changes value from ''8'' to ''0'' [-Woverflow]|

And, when executed, it will produce the following output −

Sizeof(Age): 4
Age.age: 4
Age.age: 7
Age.age: 0

You can use Bit Fields in situations where the available storage is limited. Bit Fields also prove efficient when devices transmit status or information encoded into multiple bits. Whenever certain encryption programs need to access the bits within a byte, bit fields are used to define the data structure.