Bit Arrays

If in a program a variable is to take only two values 1 and 0, we really need only a single bit to store it. Similarly, if a variable is to take values from 0 to 3, then two bits are sufficient to store these values. And if a variable is to take values from 0 through 7, then three bits will be enough, and so on. Why waste an entire integer when one or two or three bits will do? Because there aren't any one bit or two bit or three bit data types available in C. However, when there are several variables whose maximum values are small enough to pack into a single memory location, we can use `bit fields' to store several values in a single integer. Bit fields are discussed in most standard C texts. They are usually used when we want to store assorted information which can be accommodated in 1, 2, 3 bits etc.

For example, the following data about an employee can be easily stored using bit fields.

(a) male or female
(b) single, married, divorced or widowed
(c) have one of the eight different hobbies
(d) can choose from any of the fifteen different schemes proposed by the company to pursue his/her hobby

This means we need one bit to store gender, two to store marital status, three for hobby, and four for scheme (with one value used for those who are not desirous of availing any of the schemes). We need ten bits altogether, which means we can pack all this information into a single integer, since an integer is 16 bits long. At times we may need to store several True or False statuses. In such cases instead of using bit fields using an array of bits would be more sensible. On this array we may be required to perform the following operations:

(a) Set a bit (make it 1).
(b) Clear a bit (make it 0).
(c) Test the status of a bit in the array.
(c) Reach the appropriate bit slot in the array.
(d) Generate a bit mask for setting and clearing a bit.

We can implement these operations using macros given below:

#define CHARSIZE 8

#define MASK(y) ( 1 << y % CHARSIZE )

#define BITSLOT(y) ( y / CHARSIZE )

#define SET( x, y) ( x[BITSLOT(y)] |= MASK(y) )

#define CLEAR(x, y) ( x[BITSLOT(y)] &= ~MASK(y) )

#define TEST(x, y) ( x[BITSLOT(y)] & MASK(y) )

#define NUMSLOTS(n) ((n + CHARSIZE - 1) / CHARSIZE)

Using these macros we can declare an array of 50 bits be saying,

char arr[NUMSLOTS(50)] ;

To set the 20th bit we can say,

SET ( arr, 20 ) ;

And if we are to test the status of 40th bit we may say,

if ( TEST ( arr, 40 ) )

Using bit arrays often results into saving a lot of precious memory. For example, the following program which implements the Sieve of Eratosthenes for generating prime numbers smaller than 100 requires only 13 bytes. Had we implemented the same logic using an array of integers we would have required an array of 100 integers, that is 200 bytes.

#include "stdio.h"

#include "string.h"

 

#define MAX 100

 

main( )

{

char arr[NUMSLOTS(MAX)] ;

int i, j ;

 

memset ( arr, 0, NUMSLOTS(MAX) ) ;

 

for ( i = 2 ; i < MAX ; i++ )

{

if ( !TEST ( arr, i ) )

{

printf ( "\n%d", i ) ;

 

for ( j = i + i ; j < MAX ; j += i )

SET ( arr, j ) ;

}

}

}