//****************************************************************************
//
// CLASS COBLIST DEFINATION
//
//****************************************************************************
#include <windows.h>
#define ASSERT
#define POSITION COBNODE*
struct COBNODE
{
POSITION pNext;
void* pItem;
};
class COBLIST
{
protected:
POSITION m_pHead;
POSITION m_pTail;
virtual BOOL Compare(void* pItemToCompare, void* pComparator)
{ return(pItemToCompare == pComparator); };
public:
COBLIST() : m_pHead(NULL), m_pTail(NULL) { };
virtual ~COBLIST();
virtual void * RemoveAt(POSITION rPos);
void EmptyList();
POSITION AddTail(void* pItem);
void * GetTail();
void * GetNext(POSITION& rPos);
void * SafeGetFromPosition(POSITION rPos);
POSITION GetPosition(void* pItem);
POSITION Lookup(void* pComparator);
POSITION GetHeadPosition() { return (m_pHead); };
POSITION GetTailPosition() { return (m_pTail); };
BOOL IsEmpty() { return (!m_pHead); };
#ifdef DEBUG
void * GetHead();
void * RemoveHead();
void * RemoveTail();
void * GetFromPosition(POSITION rPos);
#else
void * GetHead() { return GetFromPosition(GetHeadPosition());};
void * RemoveHead() { return RemoveAt(m_pHead); };
void * RemoveTail() { return RemoveAt(m_pTail); };
void * GetFromPosition(POSITION rPos){return (NULL == rPos) ? NULL : (rPos->pItem);};
#endif
};
=================================================================
#include "a.h"
//类的实现如下:
//****************************************************************************
//
// CLASS COBLIST
//
//****************************************************************************
//****************************************************************************
//
// Destructor
//
//****************************************************************************
COBLIST::~COBLIST()
{
ASSERT(IsEmpty());
}
#ifdef DEBUG
VOID* COBLIST::GetHead()
{
ASSERT(m_pHead);
if (NULL == m_pHead)
return NULL;
return m_pHead->pItem;
}
#endif
VOID* COBLIST::GetTail()
{
ASSERT(m_pTail);
if (NULL == m_pTail)
return NULL;
return m_pTail->pItem;
}
//****************************************************************************
//
// VOID* COBLIST::GetNext(POSITION& rPos)
//
//****************************************************************************
VOID* COBLIST::GetNext(POSITION& rPos)
{
ASSERT(rPos);
if (NULL == rPos)
return NULL;
VOID* pReturn = rPos->pItem;
rPos = rPos->pNext;
return pReturn;
}
//****************************************************************************
//
// VOID* COBLIST::RemoveAt(POSITION Pos)
//
//****************************************************************************
VOID* COBLIST::RemoveAt(POSITION Pos)
{
if (NULL == Pos)
return NULL;
VOID* pReturn = NULL;
if (m_pHead)
{
if (m_pHead == Pos)
{
// Removing the first element in the list
m_pHead = Pos->pNext;
pReturn = Pos->pItem;
delete Pos;
if (NULL == m_pHead)
{
// Removing the only element!
m_pTail = NULL;
}
}
else
{
POSITION pCur = m_pHead;
while (pCur && pCur->pNext)
{
if (pCur->pNext == Pos)
{
// Removing
pCur->pNext = Pos->pNext;
if (m_pTail == Pos)
{
m_pTail = pCur;
}
pReturn = Pos->pItem;
delete Pos;
break;
}
pCur = pCur->pNext;
}
}
}
return pReturn;
}
//****************************************************************************
//
// POSITION COBLIST::AddTail(VOID* pItem)
//
//****************************************************************************
POSITION COBLIST::AddTail(VOID* pItem)
{
POSITION posRet = NULL;
if (m_pTail)
{
if (m_pTail->pNext = new COBNODE)
{
m_pTail = m_pTail->pNext;
m_pTail->pItem = pItem;
m_pTail->pNext = NULL;
}
else
return NULL;
}
else
{
ASSERT(!m_pHead);
if (m_pHead = new COBNODE)
{
m_pTail = m_pHead;
m_pTail->pItem = pItem;
m_pTail->pNext = NULL;
}
}
return m_pTail;
}
//****************************************************************************
//
// void COBLIST::EmptyList()
//
//****************************************************************************
void COBLIST::EmptyList()
{
while (!IsEmpty())
{
RemoveAt(GetHeadPosition());
}
}
#ifdef DEBUG
VOID* COBLIST::RemoveTail()
{
ASSERT(m_pHead);
ASSERT(m_pTail);
if ((NULL == m_pHead) || (NULL == m_pTail))
return NULL;
return RemoveAt(m_pTail);
}
VOID* COBLIST::RemoveHead()
{
ASSERT(m_pHead);
ASSERT(m_pTail);
if ((NULL == m_pHead) || (NULL == m_pTail))
return NULL;
return RemoveAt(m_pHead);
}
void * COBLIST::GetFromPosition(POSITION Pos)
{
void * Result = SafeGetFromPosition(Pos);
ASSERT(Result);
return Result;
}
#endif /* DEBUG */
//****************************************************************************
//
// POSITION COBLIST::GetPosition(void* _pItem)
//
//****************************************************************************
POSITION COBLIST::GetPosition(void* _pItem)
{
POSITION Position = m_pHead;
while (Position)
{
if (Position->pItem == _pItem)
{
break;
}
GetNext(Position);
}
return Position;
}
//****************************************************************************
//
// POSITION COBLIST::Lookup(void* pComparator)
//
//****************************************************************************
POSITION COBLIST::Lookup(void* pComparator)
{
POSITION Position = m_pHead;
while (Position)
{
if (Compare(Position->pItem, pComparator))
{
break;
}
GetNext(Position);
}
return Position;
}
//****************************************************************************
//
// void * COBLIST::SafeGetFromPosition(POSITION Pos)
//
//****************************************************************************
void * COBLIST::SafeGetFromPosition(POSITION Pos)
{
// Safe way to validate that an entry is still in the list,
// which ensures bugs that would reference deleted memory,
// reference a NULL pointer instead
// (e.g. an event handler fires late/twice).
// Note that versioning on entries would provide an additional
// safeguard against re-use of a position.
// Walk list to find entry.
POSITION PosWork = m_pHead;
while (PosWork)
{
if (PosWork == Pos)
{
return Pos->pItem;
}
GetNext(PosWork);
}
return NULL;
}
//****************************************************************************
//
// COBLIST Utility routines
//
//****************************************************************************
//****************************************************************************
//
// POSITION AddNode(PVOID pv, COBLIST ** ppList)
//
// Add a node to a list.
// Initializes the ObList, if necessary.
// Returns the position in the list or NULL if there was a problem.
//
//****************************************************************************
POSITION AddNode(PVOID pv, COBLIST ** ppList)
{
ASSERT(NULL != ppList);
if (NULL == ppList)
return NULL;
if (NULL == *ppList)
{
*ppList = new COBLIST();
if (NULL == *ppList)
return NULL;
}
return (*ppList)->AddTail(pv);
}
//****************************************************************************
//
// PVOID RemoveNode(POSITION * pPos, COBLIST *pList)
//
// Remove a node from a list.
// Sets pPos to NULL
//
//****************************************************************************
PVOID RemoveNode(POSITION * pPos, COBLIST *pList)
{
if ((NULL == pList) || (NULL == pPos))
return NULL;
PVOID pv = pList->RemoveAt(*pPos);
*pPos = NULL;
return pv;
}
//该类使用起来很简单,和MFC的CList差不多。