CLIST 简单代码

//****************************************************************************
//
// 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差不多。