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{unsignedint widthValidated;unsignedint 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{unsignedint widthValidated :1;unsignedint 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{unsignedint widthValidated;unsignedint heightValidated;} status1;/* define a structure with bit fields */struct{unsignedint widthValidated :1;unsignedint heightValidated :1;} status2;intmain(){printf("Memory size occupied by status1: %d\n",sizeof(status1));printf("Memory size occupied by status2: %d\n",sizeof(status2));return0;}
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 −
| Element | Description |
|---|---|
| type | An integer type that determines how a bit-field’s value is interpreted.The type may be int, signed int, or unsigned int. |
| member_name | The name of the bit-field. |
| width | Number of bits in the bit-field. “width” must be less than or equal to bit width of specified type. |
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{unsignedint 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{unsignedint age :3;} Age;intmain(){
Age.age =4;printf("Sizeof(Age): %d\n",sizeof(Age));printf("Age.age: %d\n", Age.age);
Age.age =7;printf("Age.age : %d\n", Age.age);
Age.age =8;printf("Age.age : %d\n", Age.age);return0;}
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.
