Bitshifting

.: Bit shifting using C Language :.

This is a small, but yet funny program, that demonstrates how to use bit shifting for simple operations using the C Language.

Try to keep this in mind:

• Move 1 bit to the left (<): multiply by 2
• Move 1 bit to the right (>): divide by 2

For more information on Bit shifting and Bitwise operations take a look at:
Bitwise operations 

 /*
  * Flag bits test.
  * This program shows how to implement
  * flags operations using the eight bits
  * of a char variable.
  *
  * Gabriel Marques
  * snortt@gmail.com
  *
  */
 
 /*
  * Imagine you need to use flags to control
  * the state of something. Think of 8 flags,
  * for instance, for controlling 8 basic
  * functions of a super advanced robot! ;-)
  *
  * Things that require binary state, such as
  * Unit_Status, Engage_Battle, Force_Field, etc
  * require ON or OFF control.
  *
  * You could use variables to control each state,
  * but think of the huge waste you would have
  * as all of these states are binary values!
  *
  * char Unity_Status[] = "On"; <-- This would require
  * much more space than a simple 0 or 1 as it would
  * allocate memory for 3bytes! ('O', 'n', '\n').
  * And you would also need to deal with strings
  * comparison to test each status!
  *
  * Now, think of a single bit for each status.
  * As a char variable is 1 byte long, we would
  * have 8 bits to store information on a single char! :-)
  *
  * Using bit shifts we could manipulate each bit inside
  * our 1 byte (8 bits) char:
  *
  * You can see the operation and the bit it affects below:
  *
  *  1<<0 --> 00000001 << 0    00000001 --> Bit 0
  *  1<<1 --> 00000001 << 1    00000010 --> Bit 1
  *  1<<2 --> 00000001 << 2    00000100 --> Bit 2
  *  1<<3 --> 00000001 << 3    00001000 --> Bit 3
  *  1<<4 --> 00000001 << 4    00010000 --> Bit 4
  *  1<<5 --> 00000001 << 5    00100000 --> Bit 5
  *  1<<6 --> 00000001 << 6    01000000 --> Bit 6
  *  1<<7 --> 00000001 << 7    10000000 --> Bit 7
  *
  *
  * Let's take a look at a simple example, regarding our
  * super advanced robot and its behavior.
  *
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 
 /* Definition of each funcionality flag */
 const unsigned char UNITY_STATUS             = (1<<0); /* Bit 0 */
 const unsigned char UNITY_ENGAGED_FOR_BATTLE = (1<<1); /* Bit 1 */
 const unsigned char UNITY_DEFLECTOR_SHIELD   = (1<<2); /* Bit 2 */
 const unsigned char UNITY_LASER_CANNON       = (1<<3); /* Bit 3 */
 const unsigned char UNITY_MISSLE_ARMED       = (1<<4); /* Bit 4 */
 const unsigned char UNITY_MOVE               = (1<<5); /* Bit 5 */
 const unsigned char UNITY_AI_SYSTEM_FAILURE  = (1<<6); /* Bit 6 */
 const unsigned char UNITY_GENERAL_FAILURE    = (1<<7); /* Bit 7 */
 
 /*
  * Now that we have the flags defined we can manipulate
  * them to test if our robot (UNITY) has some modes ON or OFF
  * as you will see later inside the main program.
  */
 
 int main() {
 
     unsigned char unity_control_flags;   /* This controls our robot ;-) */
     unity_control_flags = 0;             /* This disables everything */
 
     /* Let's turn ON our robot */
     unity_control_flags |= UNITY_STATUS;
 
     /* Let's make our unity start its deflector shield */
     unity_control_flags |= UNITY_DEFLECTOR_SHIELD;
 
     /* During a battle, let's suppose our system is damaged */
     unity_control_flags |= UNITY_GENERAL_FAILURE;
 
     /*
      * Now, let's test some status flags of our robot
      * We do this by testing if some bits are set to 1
      * what will result in a TRUE test.
      */
 
     /* Let's see if it is turned on*/
     if ( (unity_control_flags & UNITY_STATUS) != 0 )
         printf("Unity is on and waiting for instructions!\n");
     else
         printf("Unity is off!\n");
 
     /* Let's test if the unity has its shield on */
     if ((unity_control_flags & UNITY_DEFLECTOR_SHIELD) != 0)
         printf("Unity has its deflector shield on!\n");
     else
         printf("Deflector shield is down! Unity is vulnerable!\n");
 
     /* And we do the same test for a general system failure */
     if ((unity_control_flags & UNITY_GENERAL_FAILURE) != 0)
         printf("Warning! General system failure!\n");
     else
         printf("Unity system is healthy!\n");
 
     /*
      * Now let's suppose we need to turn some features off
      * Let's pretend we've just fixed your system failure problem.
      * We need to reset the corresponding flag!
      *
      * We do this by using the flags variable AND NOT the
      * desired functionality (~)
      */
      unity_control_flags &= ~UNITY_GENERAL_FAILURE;
 
      /* Let's check if it worked */
      /* And we do the same test for a general system failure */
      if ((unity_control_flags & UNITY_GENERAL_FAILURE) != 0)
         printf("Warning! General system failure!\n");
      else
         printf("Unity system is healthy!\n");
 
 
      return 0;
 }