# Bit masking and bit flags. Managing data efficiently

Suppose you are given a situation where you have to produce some output which depends on various arguments(flags) that the user provides.

For ex, lets say you are given a number and you are asked to do some tests on it:

1. Is the number postive?
2. Is the magnitude(number) odd?
3. Is the magnitude(number) prime?

You are also asked to save all the test results in memory so that you can pass it to other functions if required.

A simple implementation would be:

``````#include <stdio.h>

// fill in the code
int checkPos(int x){ };
int checkOdd(int x){ };
int checkPrime(int x){ };

int main(void) {
int isPos, isOdd, isPrime;
int x;
printf("Enter a number: ");
scanf("%d", &x);

isPos = checkPos(x);
isOdd = checkOdd(x);
isPrime = checkPrime(x);

}
``````

So here, we have saved the answer to each result in 3 int variables. So basically, it takes up 12 bytes(96 bits) just to store 3 results. It has a large memory footprint and there is actually a better way to acheive the same result by utilising individual bits of an integer variable to represent the result.

We can make a 8 bit unsigned int (`uint8_t`) and utilise each individual bit of that integer to store a binary result(Notice that the answer to all the questions is binary Yes/No).

``````#include <stdio.h>

// fill in the code
int checkPos(int x){ };
int checkOdd(int x){ };
int checkPrime(int x){ };

int main(void) {
uint8_t flags = 0;
int x;
printf("Enter a number: ");
scanf("%d", &x);
}
``````

Here, bitwise representation of `flags` is just : `00000000`

We can use the 3 right most bits to store the result of the questions. For example, if `x` is postive and odd but not prime, then `flag` should be:

`00000011`

last bit: isPositive?

second last bit: isOdd?

third last bit: isPrime?

The methods that we will be using to change individual bits of `flags` is called Bitmasking.

Lets see some common Bitmask operations:

### 1. Turning ON bits

To turn on a bit in any particular location is basically changing that bit value to 1. We will use the bitwise `OR` for that.

In the above case, since `x` is postive, we need to turn of the last bit. Take the bitwise `OR` of `flags` and a number whose last bit is 1 and all other bits are 0.

``````flags = flags | (1<<0)
``````

So here,

``````flags --> 00000000
(1<<0)--> 00000001
========================== OR
flags --> 00000001
``````

Similarly, for turning on the second last bit:

``````flags = flags | (1<<1)
``````

So here,

``````flags --> 00000000
(1<<1)--> 00000010
========================== OR
flags --> 00000010
``````

We can also turn on multiple bits at the same time:

``````flags = flags | (1<<0) | (1<<1)
``````
``````flags --> 00000000
(1<<0)--> 00000001
(1<<1)--> 00000010
========================== OR
flags --> 00000011
``````

### 2. Turning OFF bits

We can turn off bits, by using the bitwise `AND` and `~`(bitwise complement) operators.

Suppose, the current state of `flags` is `00000011` and we want to turn off the second last bit.

``````flags = flags & ~(1<<1)
``````
``````flags -->  00000011
~(1<<1)--> 11111101
========================== AND
flags -->  00000001
``````

### 3. Toggling bits

Toggling bits basically means to toggle(inverse) the state of a particular bit. If the bit is ON, turn it OFF and vice versa.

It can be acheived by using the `XOR` operator.

Suppose we want to toggle the second last bit of `00000011`

``````flags = flags ^ (1<<1)
``````
``````flags -->  00000011
(1<<1)-->  00000010
========================== XOR
flags -->  00000001
``````

Now, lets toggle the third last bit:

``````flags = flags ^ (1<<2)
``````
``````flags -->  00000001
(1<<2)-->  00000100
========================== XOR
flags -->  00000101
``````

### 4. Querying the status of bits.

Now that we know how to mask individual bits, its also important to know how to actually query the state of bit in a particular location.

We use the `AND` operator for this. Lets say our flag is `00000111`

We need to know the state of third last bit.

``````query = flags & (1<<2)
``````
``````flags -->  00000111
(1<<2)-->  00000100
========================== AND
query -->  00000100
``````

By comparing `query` with `(1<<2)`, we can know the state:

``````if (query == (1<<2)){
// third last bit is ON.
}
``````

Using all the above bitmasking functions, we can write a cleaner code with less memory footprint. Our original code would look like:

``````#include <stdio.h>
#include <stdint.h>

#define ISPOS (1<<0)
#define ISODD (1<<1)
#define ISPRIME (1<<2)

// fill in the code such
// that each function returns
// corresponding macro.
int checkPos(int x){
if (x > 0)
return ISPOS;
else
return 0;
};

int checkOdd(int x){ };
int checkPrime(int x){ };

int main(void) {
uint8_t flags = 0;
int x;
printf("Enter a number: ");
scanf("%d", &x);

flags |= checkPos(x) | checkOdd(x) | checkPrime(x);

}
``````