In this example, we have the binary number, 10101010. You will notice in the diagram, the 'Bit Position' of each 1 or 0. The bit farthest to the right, Bit 0, is known as the Least Significant Bit. Conversely, Bit 7 in this example, is known as the Most Significant Bit. The algorithm for translating a binary number to our standard Decimal number system is easy:
v = The value of the Bit (either 1 or 0 in Binary)
B = The Base numbering system. Binary is 2, Decimal is 10, Hexidecimal is 16, etc
p = The Bit Position The basic formula v * (B^p) determines the value of each bit. If you have an 8 bit number as above in our example, you would add each of the values derived from the formula, together. Our example about would be:

(1 * (2^7)) + (0 * (2^6)) + (1 * (2^5)) + (0 * (2^4)) + (1 * (2^3)) + (0 * (2^2)) + (1 * (2^1)) + (0 * (2^0))

**Note** I hope everyone remembers, any number to the 0 power equals 1.

So, based on that, (1*128)+(0*64)+(1*32)+(0*16)+(1*8)+(0*4)+(1*2)+(0*1) = 170
Now, if you haven't already done so, take a look at the sidebar on Datatypes. [ See Sidebar "Data Types" ]
You will notice something interesting. Look at the datatype, unsigned char. You'll notice it's 8 bits in length, and its maximum value is 255. Apply the above formula to 8 bits, all 1's; 255. Starting to make sense?
You might then notice, that the 'char datatype is also 8 bits, but its value range is -128 to 127. That is because the Most Significan Bit is used to signify the 'sign' of the number: if the MSB is 1, the number is Negative, if the MSB is 0, the number is positive.If a variable is declared as 'char', the value can be 'signed' and therefor bits 0-6 are for the number, and bit 7 holds the 'sign'. The maximum value of 6 bits is 127. So how do we get-128? Well, the value 00000000 would be 0, not Negative 0. So, 10000000 wouldn't be Positive zero, its -128.

When writing binary numbers, its good to segment them into 4 bit groups ( 4 bits are called a Nibble (or Nybble), and 8 bits are a Byte )…

...ie- 1101 1111 0011 0001

it makes them much easier to read, and you’re less likely to loose your place. And, there's also another reason for doing this, as you’ll learn next.

     FLAG = 5; 
     result = ( FLAG | 8 );

/***************************************************************************/
/* A Sample program using XOR encryption                                   
/***************************************************************************/
#include <stdio.h>
#include <ctype.h>
#define KEY 0x84 /* the ‘ä’ character (ASCII 132) */
int main(void)
{
        int orig_char, new_char;
        while ((orig_char=getchar()) != EOF)
        {
                new_char=orig_char ^ KEY;
                if (iscntrl(orig_char) || iscntrl(new_char))
                        putchar(orig_char);
                else
                        putchar(new_char);
        }
        return 0;
}

/***************************************************************************/
/* Swaping two integers without a temporary storage
/* - A Tired Lame 0ld Hack, or a Clever Example?
/* sumitted by David Lee, UK                                                                               
/***************************************************************************/
#include <stdio.h>
int main(void)
{
        unsigned int a, b;
        a=112;
        b=32;
        a ^=b;  /* step 1 – ‘a’ now equals 80  */
        b ^= a; /* step 2 – ‘b’ now equals 112 */
        a ^=b;  /* step 3 - ‘a’ now equals 32  */
        printf("A=%d B=%d\n", a, b);
}

/**********************************************************************/
/* A Bitwise Arithmetic Example 
/* Submitted by Jos A. Horsmeier 
/* © 1998 Jos A. Horsmeier 
/**********************************************************************/
#include <stdio.h>
/* add two numbers without using the '+' operator */
unsigned int add(unsigned int a, unsigned int b)
{
        unsigned int c= 0;
        unsigned int r= 0;
        unsigned int t= ~0;
        for (t= ~0; t; t>>= 1)
         {
                r<<= 1;
                r|= (a^b^c)&1;
                c= ((a|b)&c|a&b)&1;
                a>>= 1;
                b>>= 1;
         }
        for (t= ~0, c= ~t; t; t>>= 1)
         {
                c<<= 1;
                c|= r&1;
                r>>= 1;
         }
        return c;
}

/* multiply two numbers without using the '*' operator */
unsigned int mul(unsigned int a, unsigned int b)
{
        unsigned int r;
        for (r= 0; a; b <<= 1, a >>= 1)
                if (a&1)
                        r = add(r, b);
        return r;
}

/* driver program for the above two functions */
int main(int argc, char* argv[])
{
        printf("%d*%d= %d\n", atoi(argv[1]), atoi(argv[2]),
                mul(atoi(argv[1]), atoi(argv[2])));
        printf("%d+%d= %d\n",atoi(argv[1]), atoi(argv[2]),
                add(atoi(argv[1]), atoi(argv[2])));
        return 0;
}