一个模板类问题

[mz02005]

我写了一个链表模板类, 编写了测试代码, 发生错误, 哪一位高手替我检查一下错在哪儿.

下面的这些是测试代码

#include "mztempl.h"
using namespace mzdatastruct;

class my1
{
public:
CChain<int> m_i;

int a;

my1()
{
a = 100;
m_i.AddTail(&a);
}
my1(const my1& p)
{
*this = p;
}

void operator = (const my1& p)
{
a = p.a;
m_i.RemoveAll();

ELEMENT_POSITION pos = m_i.GetHeadPosition();
while (pos)
{
int mmm = p.m_i.GetAt(pos);
m_i.AddTail(&mmm);
p.m_i.GetNext(pos);
}
}
};

class my_root
{
public:
int b;
CChain<my1> my;
my_root()
{
my1 m;
my.AddTail(&m);
}

my_root(const my_root& p)
{
*this = p;
}

void operator = (const my_root& p)
{
b = p.b;

my.RemoveAll();
ELEMENT_POSITION pos = p.my.GetHeadPosition();
while (pos)
{
my1 temp = p.my.GetAt(pos);
my.AddTail(&temp);
p.my.GetNext(pos);
}
}
};

[mz02005]

void CTestMyClassDlg::OnOK()
{
my_root mr;
my_root o;
o.b = 100;
mr = o;
}

// 下面是链表类的代码
#ifndef _MZTEMPL_DATASTRUCT
#define _MZTEMPL_DATASTRUCT

#include <assert.h>

namespace mzdatastruct
{
typedef void* ELEMENT_POSITION;

// 链表类的模板类
template <class Type> class CChain
{
protected:
struct CChainNode
{
struct CChainNode* pNext;
struct CChainNode* pPrev;

Type data;
};

public:
int GetCount() const;
bool IsEmpty() const;

Type GetHead() const;
Type& GetHead();
Type GetTail() const;
Type& GetTail();

Type RemoveHead();
Type RemoveTail();

// 删除所有的节点元素
void RemoveAll();

// 添加在头之前, 或者添加在尾之后, 返回的位置指针是添加的元素的指针
ELEMENT_POSITION AddHead(Type*);
ELEMENT_POSITION AddTail(Type*);
void AddHead(CChain*);
void AddTail(CChain*);

ELEMENT_POSITION GetHeadPosition() const;
ELEMENT_POSITION GetTailPosition() const;
Type& GetPrev(ELEMENT_POSITION&); // 返回当前位置的值(如果有), 指针指向上一个
Type GetPrev(ELEMENT_POSITION&) const;
Type& GetNext(ELEMENT_POSITION&); // 返回当前位置的值(如果有), 指针指向下一个
Type GetNext(ELEMENT_POSITION&) const;

Type& GetAt(ELEMENT_POSITION);
Type GetAt(ELEMENT_POSITION) const;
void SetAt(ELEMENT_POSITION, Type*);
void RemoveAt(ELEMENT_POSITION);

ELEMENT_POSITION InsertBefore(ELEMENT_POSITION, Type*);
void InsertBefore(ELEMENT_POSITION, CChain*);
ELEMENT_POSITION InsertAfter(ELEMENT_POSITION, Type*);
void InsertAfter(ELEMENT_POSITION, CChain*);

ELEMENT_POSITION Find(Type*, ELEMENT_POSITION start_after = NULL) const;
ELEMENT_POSITION FindIndex(int) const;

// 构造和析构
CChain();
~CChain();

void operator = (const CChain& chain);

protected:
CChainNode* m_pHead, *m_pTail;
int m_nCount;
};

// 链表类的实现
template <class Type> CChain<Type>::CChain()
{
m_nCount = 0;

// 建立头尾节点(用于方便的操作链表)
m_pHead = new struct CChainNode;
m_pTail = new struct CChainNode;
assert(m_pHead && m_pTail);

m_pHead->pPrev = NULL;
m_pTail->pNext = NULL;
m_pHead->pNext = m_pTail;
m_pTail->pPrev = m_pHead;
}
template <class Type> CChain<Type>::~CChain()
{
RemoveAll();

delete m_pHead;
delete m_pTail;
}
template <class Type> void CChain<Type>::operator = (const CChain& chain)
{
RemoveAll();
AddTail((CChain*) &chain);
}

template <class Type> int CChain<Type>::GetCount() const { return m_nCount; }
template <class Type> bool CChain<Type>::IsEmpty() const { return (m_nCount == 0); }

template <class Type>
Type& CChain<Type>::GetHead() { assert(m_nCount); return m_pHead->pNext->data; }
template <class Type>
Type CChain<Type>::GetHead() const { assert(m_nCount); return m_pHead->pNext->data; }

template <class Type>
Type& CChain<Type>::GetTail() { assert(m_nCount); return m_pTail->pPrev->data; }
template <class Type>
Type CChain<Type>::GetTail() const { assert(m_nCount); return m_pTail->pPrev->data; }

template <class Type>
Type CChain<Type>::RemoveHead()
{
assert(m_nCount > 0);

CChainNode* p = m_pHead->pNext;
p->pNext->pPrev = p->pPrev;
p->pPrev->pNext = p->pNext;
Type type_return = p->data;
delete p;
m_nCount --;

return type_return;
}
template <class Type>
Type CChain<Type>::RemoveTail()
{
assert(m_nCount > 0);

CChainNode* p = m_pTail->pPrev;
p->pPrev->pNext = p->pNext;
p->pNext->pPrev = p->pPrev;
Type type_return = p->data;
delete p;
m_nCount --;

return type_return;
}

template <class Type>
void CChain<Type>::RemoveAll()
{
for (CChainNode* p = m_pHead->pNext; p != m_pTail;)
{
CChainNode* pDelete = p;
p = p->pNext;
delete pDelete;
}

m_nCount = 0;
}

template <class Type>
ELEMENT_POSITION CChain<Type>::AddHead(Type* ptype_data)
{
assert(ptype_data);
struct CChainNode* p = new struct CChainNode;
assert(p);

p->data = *p_type_data;
p->pNext = m_pHead->pNext;
m_pHead->pNext->pPrev = p;
p->pPrev = m_pHead;
m_pHead->pNext = p;

m_nCount ++;
return (ELEMENT_POSITION) p;
}
template <class Type>
void CChain<Type>::AddHead(CChain* pChain)
{
assert(pChain);

ELEMENT_POSITION pos = pChain->GetTailPosition();
while (pos)
{
AddHead(&pChain->GetAt(pos));
pChain->GetPrev(pos);
}
}

template <class Type>
ELEMENT_POSITION CChain<Type>::AddTail(Type* ptype_data)
{
assert(ptype_data);
struct CChainNode* p = new struct CChainNode;
assert(p);

p->data = *ptype_data;
p->pNext = m_pTail;
p->pPrev = m_pTail->pPrev;
m_pTail->pPrev->pNext = p;
m_pTail->pPrev = p;

m_nCount ++;
return (ELEMENT_POSITION) p;
}
template <class Type>
void CChain<Type>::AddTail(CChain* pChain)
{
assert(pChain);

ELEMENT_POSITION pos = pChain->GetHeadPosition();
while (pos)
{
AddTail(&pChain->GetAt(pos));
pChain->GetNext(pos);
}
}

template <class Type>
ELEMENT_POSITION CChain<Type>::GetHeadPosition() const
{
return (m_nCount ? (ELEMENT_POSITION) (m_pHead->pNext) : (ELEMENT_POSITION) NULL);
}
template <class Type>
ELEMENT_POSITION CChain<Type>::GetTailPosition() const
{
return (m_nCount ? (ELEMENT_POSITION) (m_pTail->pPrev) : (ELEMENT_POSITION) NULL);
}

template <class Type>
Type& CChain<Type>::GetPrev(ELEMENT_POSITION& pos)
{
assert(pos && m_nCount);

ELEMENT_POSITION pos_temp = pos;
pos = (ELEMENT_POSITION) (((CChainNode*) pos)->pPrev);
if ((CChainNode*) pos == m_pHead)
pos = NULL;
return (((CChainNode*) pos_temp)->data);
}
template <class Type>
Type CChain<Type>::GetPrev(ELEMENT_POSITION& pos) const
{
assert(pos && m_nCount);

ELEMENT_POSITION pos_temp = pos;
pos = (ELEMENT_POSITION) (((CChainNode*) pos)->pPrev);
if ((CChainNode*) pos == m_pHead)
pos = NULL;
return (((CChainNode*) pos_temp)->data);
}

template <class Type>
Type& CChain<Type>::GetNext(ELEMENT_POSITION& pos)
{
assert(pos && m_nCount);

ELEMENT_POSITION pos_temp = pos;
pos = (ELEMENT_POSITION) (((CChainNode*) pos)->pNext);
if ((CChainNode*) pos == m_pTail)
pos = NULL;
return (((CChainNode*) pos_temp)->data);
}
template <class Type>
Type CChain<Type>::GetNext(ELEMENT_POSITION& pos) const
{
assert(pos && m_nCount);

ELEMENT_POSITION pos_temp = pos;
pos = (ELEMENT_POSITION) (((CChainNode*) pos)->pNext);
if ((CChainNode*) pos == m_pTail)
pos = NULL;
return (((CChainNode*) pos_temp)->data);
}

template <class Type>
Type& CChain<Type>::GetAt(ELEMENT_POSITION pos)
{
assert(pos && m_nCount);

return (((CChainNode*) pos)->data);
}
template <class Type>
Type CChain<Type>::GetAt(ELEMENT_POSITION pos) const
{
assert(pos && m_nCount);

return (((CChainNode*) pos)->data);
}

template <class Type>
void CChain<Type>::SetAt(ELEMENT_POSITION pos, Type* ptype_data)
{
assert(ptype_data);
assert(pos && m_nCount);

((CChainNode*) pos)->data = *ptype_data;
}

template <class Type>
void CChain<Type>::RemoveAt(ELEMENT_POSITION pos)
{
assert(pos && m_nCount);

CChainNode* p = (CChainNode*) pos;
p->pPrev->pNext = p->pNext;
p->pNext->pPrev = p->pPrev;
delete p;

m_nCount--;
}

template <class Type>
ELEMENT_POSITION CChain<Type>::InsertBefore(ELEMENT_POSITION pos, Type* ptype_data)
{
assert(ptype_data);

if (pos == NULL)
return AddHead(ptype_data);

struct CChainNode* p = new struct CChainNode;
struct CChainNode* p_pos = (struct CChainNode*) pos;
assert(p);

p->data = *ptype_data;
p->pPrev = p_pos->pPrev;
p->pNext = p_pos;
p_pos->pPrev = p;

m_nCount ++;

return (ELEMENT_POSITION) p;
}

[mz02005]

template <class Type>
void CChain<Type>::InsertBefore(ELEMENT_POSITION pos, CChain* pChain)
{
assert(pChain);

ELEMENT_POSITION source_pos = pChain->GetTailPosition();
ELEMENT_POSITION insert_pos = pos;
while (pos)
{
insert_pos = InsertBefore(insert_pos, &pChain->GetAt(source_pos));
pChain->GetPrev(source_pos);
}
}

template <class Type>
ELEMENT_POSITION CChain<Type>::InsertAfter(ELEMENT_POSITION pos, Type* ptype_data)
{
assert(ptype_data);

if (pos == NULL)
return AddTail(type_data);

struct CChainNode* p = new struct CChainNode;
struct CChainNode* p_pos = (struct CChainNode*) pos;
assert(p);

p->data = *ptype_data
p->pNext = p_pos->pNext;
p->pPrev = p_pos;
p_pos->pNext = p;

m_nCount ++;

return (ELEMENT_POSITION) p;
}
template <class Type>
void CChain<Type>::InsertAfter(ELEMENT_POSITION pos, CChain* pChain)
{
assert(pChain);

ELEMENT_POSITION source_pos = pChain->GetHeadPosition();
ELEMENT_POSITION insert_pos = pos;
while (pos)
{
insert_pos = InsertAfter(insert_pos, &pChain->GetAt(source_pos));
pChain->GetNext(source_pos);
}
}

template <class Type>
ELEMENT_POSITION CChain<Type>::Find(Type* ptype_data, ELEMENT_POSITION start_after) const
{
assert(ptype_data);

if (start_after == NULL)
start_after = GetHeadPosition();

struct CChainNode* p = (struct CChainNode*) start_after;
for (;p && p->data != *ptype_data; p = p->pNext);

if (p && p->data == *ptype_data)
return (ELEMENT_POSITION) p;
return (ELEMENT_POSITION) NULL;
}

template <class Type>
ELEMENT_POSITION CChain<Type>::FindIndex(int nIndex) const
{
if (nIndex >= m_nCount || nIndex < 0)
return (ELEMENT_POSITION) NULL;

CChainNode* p = m_pHead->pNext;
while (nIndex--)
{
p = p->pNext;
}

return (ELEMENT_POSITION) p;
}
// end of cchain

} // end namespace mzdatastruct

#endif

// 另外dbgheap.c是什么文件, 它在哪里

[In355Hz]

// RemoveAll 有点问题：

template <class Type>
void CChain<Type>::RemoveAll()
{
for (CChainNode* p = m_pHead->pNext; p != m_pTail;)
{
CChainNode* pDelete = p;
p = p->pNext;
delete pDelete;
}

m_pHead->pNext = m_pTail;
m_pTail->pPrev = m_pHead;

m_nCount = 0;
}