void Release()
{
	if (memory.size())
	{
		// iterate through the deque and remove all uninitialized blocks
		std::deque<Obj>::iterator memoryItor;
		for (memoryItor = memory.begin(); memoryItor != memory.end(); memoryItor++)
		{
			Obj o = (*memoryItor);
			RemoveInstance(o.ptr); // remove the instance
		}
		CollectGarbage(); // call the garbage collector
		numUsed = 0;
		numFree = 0;
	}
}

// remove an instance
void RemoveInstance(T* obj) 
{
	// get the address of the actual object pointer
	Obj* o = (Obj*)obj-sizeof(unsigned int);
	assert(o);
	o->refCount--; // <- fails here
	numUsed--;
	numFree++;
}

private:
	// the actual object that we keep track of
	struct Obj
	{
		unsigned int refCount;
		T* ptr;
	};
	// deque of objects
	std::deque<Obj> memory;
	unsigned int numUsed, numFree;

Obj* o = (Obj*)obj-sizeof(unsigned int);

Obj* o = (obj*)((char*)obj-sizeof(unsigned int));

Obj* o = (Obj*)obj-1;

Obj* o = (Obj*)obj-sizeof(unsigned int);

Obj *o = (Obj*)obj; o = &o[-4];

Obj* o = (obj*)((char*)obj-sizeof(unsigned int))

void Release(){	if (memory.size())	{		// iterate through the deque and remove all uninitialized blocks		std::deque<Obj>::iterator memoryItor;		for (memoryItor = memory.begin(); memoryItor != memory.end(); memoryItor++)		{			Obj &o = (*memoryItor); // <- Changed			RemoveInstance(o); // remove the instance <- Changed		}		CollectGarbage(); // call the garbage collector		numUsed = 0;		numFree = 0;	}}// remove an instancevoid RemoveInstance(Obj &obj) // <- Changed{	obj->refCount--;	numUsed--;	numFree++;}

// remove an instancevoid RemoveInstance(Obj &obj) // <- Changed{	obj->refCount--;	numUsed--;	numFree++;}

#include <stdlib.h>// Make it something you can see in memory debuggers#define FENCE_HEX 0xABAAAAAB// Notice that the structure is a multiple of 8 bytes,// malloc guarentees 8 byte alignment on 32 bit// systems. You must keep that guarantee with// your allocator. To support 64 bit you must have// 16 byte alignment.struct MemHeader{	unsigned int size;	unsigned int allocCount;	char *Ptr;	// The fence can be used to warn about buffer under-runs	// and buffer over-runs. This is something the debug crt	// does in windows but you do not need to do it. Although	// if you do replace malloc with your own functions using	// the HeapAlloc function it would be a good idea.	int fence;	// char Data[n];   // int end_fence;};// Global allocation count.unsigned int allocNum = 0;void *allocateMem ( unsigned int size ){	// The trick is to put all the memory into on single block.	// We need the size of the header + size of data + 4 for the	// ending fence	MemHeader *Header = (MemHeader *)malloc(sizeof(MemHeader)+size+4);	Header->size = size;	Header->allocCount = ++allocNum;	Header->fence = FENCE_HEX;	// Trick number 2 is to return the pointer after your header	Header->Ptr = (char*)(Header+1);	// Now you can set the ending fence	(*(int*)(Header->Ptr+size)) = FENCE_HEX;	// Give the user the pointer and they won't care about the data before or after it.	return Header->Ptr;}void freeMem ( void *ptr ){	// Although only delete guarentees safty with NULL it's nice to do so with your allocator	// but an assert here would be a good idea	if (ptr == NULL)		return;	// Check the buffer under-run fence before trying to access the header, of course	// this only protects you from small buffer under-runs.	if (*((int*)ptr-1) != FENCE_HEX)	{		// Some sort of error, exception somehow inform about the bad memory/pointer		return;	}	MemHeader *Header = (MemHeader*)ptr-1;	// Check the buffer over-run fence, it might actually be better to check this	// as an array of bytes due to alignment, but that is outside the scope of	// this example	if (*((int*)((char*)Header->Ptr+Header->size)) != FENCE_HEX)	{		// Some sort of error, exception somehow inform about the bad possible state		// of the heap from writing outside user allocated memory		return;	}	// Notice that we free the header not the pointer returned by the user. This is	// due to it all being a single allocated block.	free(Header);}int main (int /*argc*/, char * /*argv[]*/){	char *testData = (char *)allocateMem(50);	freeMem(testData);	return 0;}