This item was added on: 2004/01/21
Bit Manipulation
In C and C++, values are represented as binary values. The exact values will vary from computer to computer, but the most common sizes at the time of this writing are 127 for char, 32767 for short, and 2147483647 for int and long. The unsigned values are 255, 65535, and 4294967295 respectively. Now, these values are confusing to many programmers, much less nonprogrammers. They are obviously one less than powers of two, but when seen in source code they appear to be magic numbers. An easier way to represent these values is with the hexadecimal numbering system which shows the binary structure more clearly than decimal values. In hexadecimal, each digit corresponds to four bits of the binary value, with values from 10 to 15 being represented by the letters A through F. So the values 0x7F and 0xFF are the hexadecimal equivalent to the decimal values for char shown above, signed and unsigned respectively.
You'll notice that the hexadecimal number has two digits (the 0x merely states that the number is in hexadecimal format), each of these digits correspond to four bits of the binary value. 255 in binary is
1111 1111
We know that 1111 in decimal is 15, which is 0xF in hexadecimal. So to convert the binary value to hexadecimal, simply replace every four bits with the corresponding hexadecimal digit:
1111 = F
1111 = F

0xFF
Signed and UnsignedInteger values come in two flavors in C and C++, signed and unsigned. Unsigned values are represented by a format where each bit represents a power of two, each position has a weight (1, 2, 4, 8, 16, 32, etc..) and the value of the number is determined by adding the weights of each position whose bit is set to 1. A binary value of 0000 0010 is valued at 2 since the weight of the second position is 2 and no other bits are set to 1.
Signed values are more complicated because they must also be able to represent negative numbers. There are many different ways to go about this, increasing the confusion. The more common ways include one's complement, two's complement, and signmagnitude. All of these methods use a particular bit to mark the sign of the value, the sign is whether the value is positive or negative, 0 is positive and 1 is negative. Each method goes about marking the sign in different ways:
One's complement  This method inverts all of the bits corresponding to the
positive number to create the negative number.
Ex.

1  00000001
1  11111110
Two's complement  This method performs a one's complement, but also adds
one to the resulting number.
Ex.

1  00000001
1  11111111
Signmagnitude  This method simply toggles the sign bit.
Ex.

1  00000001
1  10000001
Because of the different methods of calculating the signedness of a value and other complications when manipulating signed bits, it is highly recommended that unsigned values are used when working with individual bits, all of the code below will be using unsigned values to avoid many of the problems that can occur. We will also restrict ourselves to unsigned int as the smallest type because many of the bit operations promote char and short values to int. Even if the char and short were unsigned to begin with, the promotion could make the value signed, which is just begging for trouble.Bit Operations
C and C++ programmers have several tools to work with bits effectively, but they appear arcane at first. We will be spending a little bit of time on what each of the operations does and how they can be chained together to manipulate bits in a simple and effective manner. There are six operators that C and C++ support for bit manipulation:
& Bitwise AND
 Bitwise OR
^ Bitwise ExclusiveOR
<< Bitwise left shift
>> Bitwise right shift
~ Bitwise complement
The bitwise AND tests two binary numbers and returns bit values of 1 for positions where both numbers had a one, and bit values of 0 where both numbers did not have one:
01001011
00010101
&

00000001
Notice that a 0,0 combination being tested results in 0, as does a 1,0 combination. Only a 1,1 combination results in a binary 1 in the resulting value. The bitwise AND is often used to mask a set of bits for testing.The bitwise OR tests two binary numbers and returns bit values of 1 for positions where either bit or both bits are one, the result of 0 only happens when both bits are 0:
01001011
00010101


01011111
Notice that a 1,0 combination being tested results in 1, as does a 1,1 combination. Only a 0,0 combination results in a binary 0 in the resulting value. The bitwise OR is used to turn bits on if they were off.The bitwise ExclusiveOR tests two binary numbers and returns bit values of 1 for positions where both bits are different, if they are the same then the result is 0:
01001011
00010101
^

01011110
The bitwise left shift moves all bits in the number to the left and fills vacated bit positions with 0.
01001011
2
<<

00101100
Shifting is very useful for dealing with individual bits in a binary number. If you want to affect every bit position then instead of working out which bit position with each new bit, simply shift to the next bit and work with the same bit position.The bitwise right shift moves all bits in the number to the right.
01001011
2
>>

??010010
Note the use of ? for the fill bits. Where the left shift filled the vacated positions with 0, a right shift will do the same only when the value is unsigned. If the value is signed then a right shift will fill the vacated bit positions with the sign bit or 0, which one is implementationdefined. So the best option is to never right shift signed values.The bitwise complement inverts the bits in a single binary number.
~01001011

10110100
The binary complement operator is unary, meaning it is only used on a single number (~num) instead of two numbers like the previous binary operators (num1 & num2, num1 << num2).The bitwise operators in C and C++ can be chained together and used for a huge number of operations, for example, if you wanted to clear the lowest order 1 bit you would say something like val & ( val  1 ). To clear all 1 bits except for the lowest bit, the statement could be changed to val & val. There are many different combinations that can be used to do just about anything with a binary number. Following are two functions which will help in playing around with the operators to figure out just how they work. A tutorial will never be able to explain such operations adequately, so you are encouraged to try things out for yourself. The following two functions will reverse the bits in a number and print all of the bits to an output stream. The print function prints the bits in reverse order, so the reversal function can be used to improve readability of the output:
The rev_bits function is a template function which can be used with any reasonable type for bit manipulation, it works by calculating the number of bits in the type passed to it by multiplying the size of the type by CHAR_BIT from <climits>. It then copies val to ret in reverse simply by copying the lowest order bit of val to ret and then shifting ret left by one, then shifts val right by one. The sequence is as follows:
Start:
val ret
 
1101 0000
copy:
1101 0001
shift:
0110 0010
copy:
0110 0010
shift:
0011 0100
copy:
0011 0101
shift:
0001 1010
copy:
0001 1011
shift:
0000 no_shift
End:
val ret
 
0000 1011
template <typename T>
T rev_bits ( T val )
{
T ret = 0;
T n_bits = sizeof ( val ) * CHAR_BIT;
for ( unsigned i = 0; i < n_bits; ++i ) {
ret = ( ret << 1 )  ( val & 1 );
val >>= 1;
}
return ret;
}
The print_bits function is also a template function which can print the bits of any reasonable data type for bit manipulation, it takes an extra argument which determines which stream to print the bits to (the most common stream would be std::cout). The function is very simple, it merely prints the value of the lowest order bit and then shifts the bits right by one. The result is that the number is actually printed in reverse, but this disadvantage is removed when print_bits is coupled with rev_bits. The only statement which may be confusing is !!( val & 1 ). What this does is test whether the lowest order bit of val is set, this test will return zero if it is not set and nonzero if it is. Note that I said nonzero and not 1, this is important because you can't be sure that ( val & 1 ) will print the correct value, so the logical negation operator is used once to create a boolean value (which is 0 or 1, nothing else) and once more to set the boolean values correctly (only one negation will result in unset bits printing as 1 and set bits as 0).
template <typename T>
void print_bits ( T val, std::ostream& out )
{
T n_bits = sizeof ( val ) * CHAR_BIT;
for ( unsigned i = 0; i < n_bits; ++i ) {
out<< !!( val & 1 );
val >>= 1;
}
}
Note that both of these functions require that the header <climits> is included for CHAR_BIT. Both functions are generic enough for any reasonable usage. Here is a possible driver the makes use of these functions to test the bitwise AND operator:
#include <iostream>
#include <climits>
// The definition of print_bits here
// The definition of rev_bits here
int main()
{
unsigned a = 0xF, b = 0x6;
print_bits ( rev_bits ( a ), std::cout );
std::cout<<'\n';
print_bits ( rev_bits ( b ), std::cout );
std::cout<<"\n&\n";
print_bits ( rev_bits ( a & b ), std::cout );
std::cout<<'\n';
return 0;
}
Have fun!