CS 3370 – Advanced C++ Programming Lab 4 – Bitwise Operations ...

CS 3370 – Advanced C++ Programming
Lab 4 – Bitwise Operations
Bitwise operations are needed when processing bit flags in operating systems calls and when
packing Boolean values into integers to conserve space. The bitwise operators are:
> shift right
| bitwise OR
&
bitwise AND
^
bitwise XOR (exclusive-or)
~ bitwise NOT (flip all bits)
These operators apply to integers and return new integer results. There are also associated
assignment operators that modify their left operand: =, |=, &=, ^=, ~=.
The shift operators take the integer to be processed as a left operand and the number of bit
positions to shift as a right operand. The left operand is usually an unsigned integer, because a
shift-right replicates the sign bit when processing a signed integer; with unsigned integers zeroes
are introduced.
To determine whether a particular bit is set or not, construct a mask, a like-sized integer with a 1
in the position of interest and zeroes elsewhere. Then AND that mask with the original integer. If
the result is non-zero, the bit is set. To illustrate, suppose we want to know if the bit in position 4
is set in the integer n. Since bits are numbered right-to-left from 0, the needed mask is
00000000000000000000000000010000
This happens to be the hex integer 0x00000010, but we don’t need to know that, because we can
construct the mask with the left-shift operator:
unsigned int mask = 1u

The value for status is !!(32) = !(0) = 1. The logical-not operator (!) converts a non-zero to zero
and a 0 to 1.
To set a bit, OR the mask with the number:
mask = 1u

Exercise
Write a class named BitWord that holds an unsigned int and implements the following
interface:
class BitWord
{
public:
explicit Bits(unsigned int n = 0);
void set(size_t pos);
void reset(size_t pos);
void flip(size_t pos);
bool test(size_t pos) const;
unsigned int extract(size_t m, size_t n) const;
operator unsigned int () const;
friend ostream& operator