内存链

1

// _AFXPLEX_.H文件

#ifndef __AFXPLEX_H__
#define __AFXPLEX_H__

struct CPlex
{
	CPlex* pNext; // 向每个内层块中添加的额外信息，指向下一个内存块首地址的指针

	// 这里是真正的数据区，BYTE data[maxNum*elementSize];
	void* data() { return this + 1; }

	// 用于申请内存的全局函数。申请cbElement大小的空间nMax个
	static CPlex* Create(CPlex*& pHead, UINT nMax, UINT cbElement);

	// 释放以当前对象为首地址（this指针）的内存链中的所有内存
	void FreeDataChain();
};

#endif // __AFXPLEX_H__

2

// _AFXCOLL.H文件

#ifndef __AFXCOLL_H__
#define __AFXCOLL_H__

#include "_afxplex_.h"

class CMapPtrToPtr
{
protected:
	// 关联（Association）
	struct CAssoc
	{
		CAssoc* pNext;	// 指向下一个CAssoc结构
		void* key;	// 键对象
		void* value;	// 值对象
	};

public:
// 构造函数（Construction）
	CMapPtrToPtr(int nBlockSize = 10);

// 属性成员（Attributes）
	// 元素的个数
	int GetCount() const;
	BOOL IsEmpty() const;
	// 在映射中查找key所对应的rValue
	BOOL Lookup(void* key, void*& rValue);

// 操作（Operations）
	// 查找或者是添加key对应的value
	void*& operator[](void* key);
	// 添加一个新的（key, vaule）对
	void SetAt(void* key, void* newValue);

	// 移除一个存在的（key, ?）对
	BOOL RemoveKey(void* key);
	void RemoveAll();

	UINT GetHashTableSize() const;
	void InitHashTable(UINT nHashSize, BOOL bAllocNow = TRUE);
	UINT HashKey(void* key) const;

// 实现（Implementation）
protected:
	CAssoc** m_pHashTable;
	int m_nHashTableSize;

	struct CPlex* m_pBlocks;	// 保存用CPlex::Create函数申请的内存块的首地址
	int m_nBlockSize;		// 指定每个内存块可以容纳多少个CAssoc结构
	CAssoc* m_pFreeList;		// 预留空间中没有被使用的CAssoc结构组成的链中第一个关联的指针
	int m_nCount;			// 记录了程序一共使用了多少个CAssoc结构，即关联的个数

	// 为一个新的CAssoc结构提供空间，相当于使用new操作符
	CAssoc* NewAssoc();
	// 释放一个CAssoc结构占用的空间，相当于使用delete操作符
	void FreeAssoc(CAssoc* pAssoc);
	// 寻找键key所在的关联
	CAssoc* GetAssocAt(void* key, UINT& nHash) const;
public:
	~CMapPtrToPtr();
};

inline int CMapPtrToPtr::GetCount() const
{ return m_nCount; }
inline BOOL CMapPtrToPtr::IsEmpty() const
{ return m_nCount == 0; }
inline void CMapPtrToPtr::SetAt(void* key, void* newValue)
{ (*this)[key] = newValue; }
inline UINT CMapPtrToPtr::GetHashTableSize() const
{ return m_nHashTableSize; }	

#endif // __AFXCOLL_H__

3

// MAP_PP.CPP文件


#include "_afxcoll.h"

CMapPtrToPtr::CMapPtrToPtr(int nBlockSize)
{
	m_pHashTable = NULL;
	m_nHashTableSize = 17;	// 默认大小
	m_pBlocks = NULL;
	m_nBlockSize = nBlockSize;
	m_pFreeList = NULL;
	m_nCount = 0;
}

inline UINT CMapPtrToPtr::HashKey(void* key) const
{
	return ((UINT)(void*)(DWORD)key) >> 4;
}

void CMapPtrToPtr::InitHashTable(UINT nHashSize, BOOL bAllocNow)
{
	if(m_pHashTable != NULL)
	{
		// 释放计算表
		delete[] m_pHashTable;
		m_pHashTable = NULL;
	}

	if(bAllocNow)
	{
		// 为计算表申请空间
		m_pHashTable = new CAssoc*[nHashSize];
		memset(m_pHashTable, 0, sizeof(CAssoc*)*nHashSize);
	}
	m_nHashTableSize = nHashSize;
}

CMapPtrToPtr::CAssoc* CMapPtrToPtr::GetAssocAt(void* key, UINT& nHash) const
{
	// 计算包含key的项在表中的位置
	nHash = HashKey(key)%m_nHashTableSize;
	if(m_pHashTable == NULL)
		return NULL;

	// 在以m_pHashTable[nHash]为头指针的链表中查找
	CAssoc* pAssoc;
	for(pAssoc = m_pHashTable[nHash]; pAssoc != NULL; pAssoc = pAssoc->pNext)
	{
		if(pAssoc->key == key)
			return pAssoc;
	}
	return NULL;
}

BOOL CMapPtrToPtr::Lookup(void* key, void*& rValue)
{
	UINT nHash;
	CAssoc* pAssoc = GetAssocAt(key, nHash);
	if(pAssoc == NULL)
		return FALSE;	// 没有在映射中

	rValue = pAssoc->value;
	return TRUE;
}

void*& CMapPtrToPtr::operator [] (void* key)
{
	UINT nHash;
	CAssoc* pAssoc;
	if((pAssoc = GetAssocAt(key, nHash)) == NULL)
	{
		if(m_pHashTable == NULL)
			InitHashTable(m_nHashTableSize);

		// 既然映射中没有用户指定的项，我们就添加一个新的关联
		pAssoc = NewAssoc();
		pAssoc->key = key;

		// 将新的关联放入计算表中（放在表头，不是表尾）
		pAssoc->pNext = m_pHashTable[nHash];
		m_pHashTable[nHash] = pAssoc;
	}
	return pAssoc->value; // 返回value的引用
}

BOOL CMapPtrToPtr::RemoveKey(void* key)
{
	if(m_pHashTable == NULL) 
		return FALSE;	// 表中什么也没有

	CAssoc** ppAssocPre;	// 记录要删除的项的地址的变量的地址（如果存在的话，我们会改变此地址处的值）
	ppAssocPre = &m_pHashTable[HashKey(key)%m_nHashTableSize];

	CAssoc* pAssoc;
	for(pAssoc = *ppAssocPre; pAssoc != NULL; pAssoc = pAssoc->pNext)
	{
		if(pAssoc->key == key)
		{
			// 移除pAssoc指向的项
			*ppAssocPre = pAssoc->pNext;  // 从表中移除
			FreeAssoc(pAssoc);	      // 释放内存
			return TRUE;
		}
		ppAssocPre = &pAssoc->pNext;
	}
	return FALSE; // 没有找到
}

CMapPtrToPtr::~CMapPtrToPtr()
{
	RemoveAll();
}

void CMapPtrToPtr::RemoveAll()
{
	if(m_pHashTable != NULL)
	{
		// 释放计算表
		delete[] m_pHashTable;
		m_pHashTable = NULL;
	}

	m_nCount = 0;
	m_pFreeList = NULL;
	m_pBlocks->FreeDataChain();
	m_pBlocks = NULL;
}

CMapPtrToPtr::CAssoc* CMapPtrToPtr::NewAssoc()
{
	// 预留的空间已经被使用完
	if(m_pFreeList == NULL)
	{
		// 向m_pBlocks指向的链中添加一个新的内存块。m_nBlockSize的值可以由用户指定
		CPlex* newBlock = CPlex::Create(m_pBlocks, m_nBlockSize, sizeof(CAssoc));

		// 将新内存块中各CAssoc结构添加到m_pFreeList指向的链中（空闲链）
		CAssoc* pAssoc = (CAssoc*)newBlock->data();
		pAssoc += m_nBlockSize -1;	// 注意，此时pAssoc指向内存块中最后一个CAssoc结构	
		for(int i = m_nBlockSize -1; i >= 0; i--, pAssoc--)
		{
			// 将pAssoc做为链的首地址添加到空闲链中（还是以相反的顺序向链中添加元素）
			pAssoc->pNext = m_pFreeList; 
			m_pFreeList = pAssoc;
		}
	}

	// 从空闲链中取出一个元素pAssoc
	CAssoc* pAssoc = m_pFreeList;
	m_pFreeList = m_pFreeList->pNext; 
	m_nCount++;				// 又多使用了一个CAssoc结构

	// 初始化新关联的值
	pAssoc->key = 0;
	pAssoc->value = 0;
	return pAssoc;
}

void CMapPtrToPtr::FreeAssoc(CAssoc* pAssoc)
{
	// 将要释放的关联做为链的首地址添加到空闲链中（以相反的顺序）
	pAssoc->pNext = m_pFreeList;
	m_pFreeList = pAssoc;
	m_nCount--;				// 释放了一个CAssoc结构

	// 如果全部的关联都没被使用，就释放所有的内存空间，包括CPlex::Create函数申请的内存块
	if(m_nCount == 0)
		RemoveAll();  // 此函数会释放所有内存空间，待会儿我们再讨论
}