Bitmap & Bitset

class Bitmap {
public:
explicit Bitmap(const int size)
: size_(size), num_words_((size + 31) / 32) {
words_.resize(size);
Reset();
}

~Bitmap() {}

int size() const { return size_; }

void Reset() {
for (int i = 0; i < num_words_; i++)
words_[i] = 0;
}

bool Get(int k) const {
return words_[k >> kUint32LengthLog] & (1<<(k & 31));
}

void Set(int k) {
words_[k >> kUint32LengthLog] |= 1<<(k & 31);
}

void Clear(int k) {
words_[k >> kUint32LengthLog] &= ~(1<<(k & 31));
}

// Return the number of size_ that is set.
int NumberOfBitsSet() const {
int num_set_bits = 0;
for (auto it = words_.begin(); it != words_.end(); ++it) {
num_set_bits += NumberOfBitsSet(*it);
}
return num_set_bits;
}

private:
static const int kUint32LengthLog = 5;
static const uint32 m1 = 0x55555555; // binary: 0101 0101 0101 0101 …
static const uint32 m2 = 0x33333333; // binary: 0011 0011 0011 0011 …
static const uint32 m4 = 0x0F0F0F0F; // binary: 0000 1111 0000 1111 …
// the sum of 256 to the power of 0,1,2,3
static const uint32 h01 = 0x01010101;

int NumberOfBitsSet(uint32 i) const {
i -= ((i >> 1) & m1);
i = (i & m2) + ((i >> 2) & m2);
return (((i + (i >> 4)) & m4) * h01) >> 24;
}

const int size_;
const int num_words_;
std::vector words_;
};

/*
Bitset
A bitset stores bits (elements with only two possible values: 0 or 1, true or false, …).

The class emulates an array of bool elements, but optimized for space allocation: generally,

each element occupies only one bit (which, on most systems, is eight times less than the smallest elemental type: char).

Each bit position can be accessed individually: for example, for a given bitset named foo, the expression foo[3] accesses its fourth bit, just like a regular array accesses its elements. But because no elemental type is a single bit in most C++ environments, the individual elements are accessed as special references type (see bitset::reference).

Bitsets have the feature of being able to be constructed from and converted to both integer values and binary strings (see its constructor and members to_ulong and to_string). They can also be directly inserted and extracted from streams in binary format (see applicable operators).

The size of a bitset is fixed at compile-time (determined by its template parameter). For a class that also optimizes for space allocation and allows for dynamic resizing, see the bool specialization of vector (vector).
*/