//<Part.五> 内存管理器，负责垃圾内存的回收

//释放基类
class baseReleaser {
protected:
	void* ptr;
public:
	//强制转换
	template<class S>
	operator S* () {
		return (S*)ptr;
	}
	bool isNull() {
		return NULL == ptr;
	}

	virtual ~baseReleaser() {}
	virtual void release() = 0;
};

//自动指针
template<class T>
class autoPointer : public baseReleaser {
private:
	autoPointer(autoPointer& e) {}
	autoPointer& operator = (autoPointer& e) {}

public:
	virtual void release() {
		T* t = (T*)ptr;
		SAFE_DELETE_PTR(t);
		ptr = NULL;
	}

	autoPointer() {
		ptr = NULL;
	}

	autoPointer(const T* t) {
		ptr = (void *)t;
	}

	autoPointer& operator=(const T* t) {
		setPointer(t);
		return *this;
	}

	void setPointer(const T* t) {
		//释放掉之前的旧指针，如果非空的话。
		release();
		ptr = (void*)t;
	}

	//取值
	T& operator*() const {
		assert(ptr);
		return *(T*)ptr;
	}

	//指针
	T* operator->() const {
		return (T*)ptr;
	}

	virtual ~autoPointer() {
		release();
	}
};

//内存管理器
class memoryGarbageCollector {
private:
	autoPointer<map<void*, baseReleaser*> > heapMem;
public:
	template<class T>
	void add(const T * t) {
		if (NULL != t) {
			void* pv = (void*)t;
			//确保同一地址的内存只回收一次垃圾
			if (heapMem->find(pv) == heapMem->end()) {
				baseReleaser* mg = new autoPointer<T>(t);
				(*heapMem)[pv] = mg;
			}
		}
	}

	memoryGarbageCollector() {
		heapMem.setPointer(new map<void*, baseReleaser*>());
	}
		   
	~memoryGarbageCollector() {
		release();
	}

	void release(){
		for (map<void*, baseReleaser*>::iterator it = heapMem->begin(); it != heapMem->end(); ++it) {
			baseReleaser* m = it->second;
			m->release();
			SAFE_DELETE_PTR(m);
		}
		heapMem->clear();
	}
};

因为greenJson中数据位于堆上，所以每个JSON类对象需要独立管理自己的内存，避免内存泄露。这些内存来自于new操作，不管是外部申请的，还是对象自己申请的，只要归对象控制的堆内存，一律放入回收器。