Laboratory Exercises, C++ Programming

32 Programming with the STL
An outline of the class (BitsetStorage is the type of the word that contains the bits):
class BitReference {
public:
BitReference(Bitset::BitStorage* pb, size_t p)
: p_bits(pb), pos(p) {}
// Operations will be added later
protected:
Bitset::BitStorage* p_bits; // pointer to the word containing bits
size_t pos; // position of the bit in the word
};
Now, operator[] in class Bitset may be defined as follows:
BitReference operator[](size_t pos) {
return BitReference(&bits, pos);
}
The actual bit fiddling is performed in the BitReference class. In order to see what we need to
implement in this class, we must study the results of some expressions involving operator[]:
bs[3] = true; // bs.operator[](3) = true; =>
// BitReference(&bs.bits,3) = true; =>
// BitReference(&bs.bits,3).operator=(true);
From this follows that we must implement the following operator function in BitReference:
BitReference& operator=(bool x); // for bs[i] = x
This function should set the bit referenced by the BitReference object to the value of x (just like
the set function in the original Bitset class). When we investigate (do this on your own) other
possibilities to use operator[] we find that we also need the following functions:
BitReference& operator=(const BitReference& bsr); // for bs[i] = bs[j]
operator bool() const; // for x = bs[i]
A4. Use the files bitset.h, bitset.cc, bitreference.h, bitreference.cc, and bitsettest1.cc. Implement
the functions in bitreference.cc and test. It is a good idea to execute the program line
by line under control of gdb, even if your implementation is correct, so you can follow
the execution closely and see what happens (turn off the -O2 switch on the compilation
command line if you do this).
2.3 Iterators
From one of the OH slides: “An iterator “points” to a value. All iterators are DefaultConstructible
and Assignable and support ++it and it++.” A ForwardIterator should additionally be
EqualityComparable and support *it, both for reading and writing via the iterator.
The most important requirement is that an iterator should point to a value. A BitsetIterator
should point to a Boolean value, and we already have something that does this: the class
BitReference! The additional requirements (++, equality test, and *) can be implemented in a
derived class. It will look like this: 11
11 This class only contains the constructs that are necessary for the bitset test program. For example, we have not
implemented postfix ++ and comparison with ==.