CMapPtrToPtr实现

1. struct CMyPlex   
2. {  
3.     CMyPlex* pNext;  
4.     void* data(void)  
5.     {  
6.         return this + 1;  
7.     }  
8.     static CMyPlex* Create(CMyPlex* &pHead, UINT nMax, UINT cbElement);  
9.     void FreeDataChain(void);  
10. };  
11. CMyPlex* CMyPlex::Create(CMyPlex* &pHead, UINT nMax, UINT cbElement)  
12. {  
13.     CMyPlex* pTmp = (CMyPlex*)new BYTE[sizeof(CMyPlex) + nMax * cbElement];  
14.       
15.     pTmp->pNext = pHead;  
16.     pHead = pTmp;  
17.     return pTmp;  
18. }  
19. void CMyPlex::FreeDataChain(void)  
20. {  
21.     CMyPlex* pTmp = this;  
22.     while (pTmp != NULL)  
23.     {  
24.         BYTE* pBytes = (BYTE*)pTmp;  
25.         CMyPlex* pNext = pTmp->pNext;  
26.         delete[] pBytes;  
27.         pTmp = pNext;  
28.           
29.     }  
30. }  
31. class CMyMapPtrToPtr  
32. {  
33. protected:  
34.     struct CMyAssoc  
35.     {  
36.         CMyAssoc* pNext;  
37.         void* key;  
38.         void* value;  
39.     };  
40. public:  
41.     CMyMapPtrToPtr(int nBlockSize = 10);  
42.     ~CMyMapPtrToPtr(void);  
43.     void InitHashTable(UINT nHashSize, BOOL bAllocNow = TRUE);  
44.     int GetCount(void) const;  
45.     BOOL IsEmpty(void) const;  
46.     void SetAt(void* key, void* newValue);  
47.     UINT GetHashTableSize(void) const;  
48.     UINT HashKey(void* key) const;  
49.     void*& operator[](void* key);  
50.     void RemoveAll(void);  
51.     BOOL RemoveKey(void* key);  
52.       
53. protected:  
54.     CMyAssoc** m_pHashTable;  
55.     int m_nHashTableSize;  
56.     struct CMyPlex* m_pBlocks;  
57.     int m_nBlockSize;  
58.     CMyAssoc* m_pFreeList;  
59.     int m_nCount;  
60.     CMyAssoc* NewMyAssoc(void);  
61.     void FreeMyAssoc(CMyAssoc* pMyAssoc);  
62.     CMyAssoc* GetMyAssocAt(void* key, UINT& nHash) const;  
63. };  
64. CMyMapPtrToPtr::CMyMapPtrToPtr(int nBlockSize /* = 10 */) : m_nBlockSize(nBlockSize)  
65. {  
66.     m_pHashTable = NULL;  
67.     m_nHashTableSize = 17;  
68.     m_pBlocks = NULL;  
69.     m_nBlockSize = nBlockSize;  
70.     m_pFreeList = NULL;  
71.     m_nCount = 0;  
72. }  
73. CMyMapPtrToPtr::~CMyMapPtrToPtr(void)  
74. {  
75.     RemoveAll();  
76. }  
77. void CMyMapPtrToPtr::InitHashTable(UINT nHashSize, BOOL bAllocNow /* = TRUE */)  
78. {  
79.     if (NULL != m_pHashTable)  
80.     {  
81.         delete[] m_pHashTable;  
82.         m_pHashTable = NULL;  
83.     }  
84.     if (bAllocNow)  
85.     {  
86.         m_pHashTable = new CMyAssoc*[nHashSize];  
87.         memset(m_pHashTable, 0, sizeof(CMyAssoc*) * nHashSize);  
88.     }  
89.     m_nHashTableSize = nHashSize;  
90. }  
91. int CMyMapPtrToPtr::GetCount(void) const  
92. {  
93.     return m_nCount;  
94. }  
95. BOOL CMyMapPtrToPtr::IsEmpty(void) const  
96. {  
97.     BOOL bRet = FALSE;  
98.     if (0 == m_nCount)  
99.     {  
100.         bRet = TRUE;  
101.     }  
102.     return bRet;  
103. }  
104. void CMyMapPtrToPtr::SetAt(void *key, void* newValue)  
105. {  
106.     (*this)[key] =newValue;  
107. }  
108. UINT CMyMapPtrToPtr::GetHashTableSize(void) const  
109. {  
110.     return m_nHashTableSize;  
111. }  
112. UINT CMyMapPtrToPtr::HashKey(void* key) const  
113. {  
114.     return ((UINT)(void*)(DWORD)key) >> 4;  
115. }  
116. void*& CMyMapPtrToPtr::operator[](void* key)  
117. {  
118.     UINT nHash = 0;  
119.     CMyAssoc* pMyAssoc = NULL;  
120.     if ((pMyAssoc = GetMyAssocAt(key, nHash)) == NULL)  
121.     {  
122.         if (NULL == m_pHashTable)  
123.         {  
124.             InitHashTable(m_nHashTableSize);  
125.         }  
126.         pMyAssoc = NewMyAssoc();  
127.         pMyAssoc->key = key;  
128.         pMyAssoc->pNext = m_pHashTable[nHash];  
129.         m_pHashTable[nHash] = pMyAssoc;  
130.     }  
131.     return pMyAssoc->value;  
132. }  
133. void CMyMapPtrToPtr::RemoveAll(void)  
134. {  
135.     if (NULL != m_pHashTable)  
136.     {  
137.         delete[] m_pHashTable;  
138.         m_pHashTable = NULL;  
139.     }  
140.     m_nCount = 0;  
141.     m_pFreeList = NULL;  
142.     m_pBlocks->FreeDataChain();  
143.     m_pBlocks = NULL;  
144. }  
145. BOOL CMyMapPtrToPtr::RemoveKey(void* key)  
146. {  
147.     BOOL bRet = FALSE;  
148.     if (NULL == m_pHashTable)  
149.     {  
150.         goto Exit0;  
151.     }  
152.       
153.     CMyAssoc** ppAssocPre = &m_pHashTable[HashKey(key) % m_nHashTableSize];  
154.       
155.     CMyAssoc* pMyAssoc = NULL;  
156.     for (pMyAssoc = *ppAssocPre; pMyAssoc != NULL; pMyAssoc = pMyAssoc->pNext)  
157.     {  
158.         if (pMyAssoc->key == key)  
159.         {  
160.             *ppAssocPre = pMyAssoc->pNext;  
161.             FreeMyAssoc(pMyAssoc);  
162.             bRet = TRUE;  
163.             goto Exit0;  
164.         }  
165.         ppAssocPre = &pMyAssoc->pNext;  
166.     }  
167. Exit0:  
168.     return bRet;  
169. }  
170. CMyMapPtrToPtr::CMyAssoc* CMyMapPtrToPtr::NewMyAssoc(void)  
171. {  
172.     if (NULL == m_pFreeList)  
173.     {  
174.         CMyPlex* pTmp = CMyPlex::Create(m_pBlocks, m_nBlockSize, sizeof(CMyAssoc));  
175.         CMyAssoc* pMyAssoc = (CMyAssoc*)pTmp->data();  
176.         pMyAssoc += m_nBlockSize - 1;  
177.         for (int i = m_nBlockSize - 1; i >= 0; i--, pMyAssoc--)  
178.         {  
179.             pMyAssoc->pNext = m_pFreeList;  
180.             m_pFreeList = pMyAssoc;  
181.         }  
182.     }  
183.     CMyAssoc* pMyAssoc = m_pFreeList;  
184.     m_pFreeList = pMyAssoc->pNext;  
185.     m_nCount++;  
186.     pMyAssoc->key = NULL;  
187.     pMyAssoc->value = NULL;  
188.     return pMyAssoc;  
189. }  
190. void CMyMapPtrToPtr::FreeMyAssoc(CMyAssoc* pMyAssoc)  
191. {  
192.     pMyAssoc->pNext = m_pFreeList;  
193.     m_pFreeList->pNext = pMyAssoc;  
194.     m_nCount--;  
195.     if (0 == m_nCount)  
196.     {  
197.         RemoveAll();  
198.     }  
199. }  
200. CMyMapPtrToPtr::CMyAssoc* CMyMapPtrToPtr::GetMyAssocAt(void* key, UINT& nHash) const  
201. {  
202.     CMyAssoc* pMyAssocRet = NULL;  
203.     nHash = HashKey(key) % m_nHashTableSize;  
204.     if (NULL == m_pHashTable)  
205.     {  
206.         goto Exit0;  
207.     }  
208.     CMyAssoc* pMyAssoc = NULL;  
209.     for (pMyAssoc = m_pHashTable[nHash]; pMyAssoc != NULL; pMyAssoc = pMyAssoc->pNext)  
210.     {  
211.         if (pMyAssoc->key == key)  
212.         {  
213.             pMyAssocRet = pMyAssoc;  
214.             goto Exit0;  
215.         }  
216.     }  
217. Exit0:  
218.     return pMyAssocRet;  
219. }