I saw a thread about a week back where someone wanted to represent a boolean value as a single bit so that they could store more values in limited memory. Sounded like a good exercise so here it is:
Code:
class CBoolArray
{
	bool initialized;
	unsigned int* array;
	int elementCount;

public:
	CBoolArray(int elements)
	{
		initialized = true;
		int arraySize = elements / 32 + ((elements % 32) ? 1 : 0);
		array = new unsigned int[arraySize];
		for (int i = 0; i < arraySize; i++)
			array[i] = 0;

		elementCount = elements;
	}

	CBoolArray()
	{
		initialized = false;
	}

	void Resize(int elements)
	{
		if (elements == elementCount)
			return;

		unsigned int* prevArray = array;
		int em32 = elements % 32;
		int ed32 = elements / 32;
		int arraySize = elements / 32 + (em32 ? 1 : 0);
		int i;
		unsigned int modValue;
 
		if (initialized)
		{
			if (elements < elementCount)
			{
				array = new unsigned int[arraySize];
				for (i = 0; i < arraySize - 1; i++)
					array[i] = prevArray[i];

				if (em32)
				{
					modValue = (1 << em32) - 1;
					prevArray[i] &= modValue;
					array[i] = prevArray[i];
				}
			}
			else
			{
				array = new unsigned int[arraySize];
				for (int i = 0; i < (ed32) + (em32 ? 1 : 0); i++)
					array[i] = prevArray[i];
				
				for(; i < arraySize; i++)
					array[i] = 0;
			}
			elementCount = elements;
		}
		else
		{
			initialized = true;
			int arraySize = ed32 + (em32 ? 1 : 0);
			array = new unsigned int[arraySize];
			for (int i = 0; i < arraySize; i++)
				array[i] = 0;

			elementCount = elements;
		}
	}

	bool Set(int element, bool value)
	{
		if (element > elementCount)
			return false;

		int ed32 = element / 32;
		int em32 = element % 32;
		unsigned int modValue;

		if (value)
		{
			modValue = 1 << em32;
			array[ed32] |= modValue;
		}
		else
		{
			modValue = 4294967296 - (1 << em32);
			array[ed32] &= modValue;
		}

		return true;
	}

	bool At(int element)
	{
		if (element > elementCount)
			return false;
		return ((array[element / 32] >> (element % 32)) & 1);
	}
};
And of course, I'd love some criticism and advice to speed it up since I'm not the most well-versed in binary operations.