从MFC中的CSinpleList学到的东西

源自： 小银

stack是一种先进后出(First in last out)的数据结构,queue是一种先进先出(first in first out)的数据结构,在stl中实现方法是用了把deque双向队列封装了一下(具体可以查看<<stl源妈解析>>大概是第4章).
今天剥离MFC中CWinThread的类时,发现是一个MFC存放线程信息的一个队列类CSimpleList,是个队列的类和以前看到的方法都不一样它用了位移来得到p->next(比较牛啊).具体代码从MFC中剥离了出来,根据这种想法又写了stack和queue的两个类,其实是想写list的嫌麻烦,就改简单的了.重在思想.

先给出 CSimpleList代码

 

Simplelist.h
#ifndef __JONES__CSIMPLELIST__
#define  __JONES__CSIMPLELIST__

class  CSimpleList
{
public:
 CSimpleList(int nNextOffset = 0);
 void Construct(int nNextOffset);

//操作
 BOOL IsEmpty() const;
 void AddHead(void* p);
 void RemoveAll();
 void* GetHead() const;
 void* GetNext(void* p) const;
 BOOL Remove(void* p);
 void** GetNextPtr(void* p) const; 

private:
 void* m_pHead;
 size_t m_nNextOffset;  //pNext的位移偏量

} ;

// 对CSimpleList的一个封装
template < class  TYPE >
class  CTypedSimpleList :  public  CSimpleList
{
public:
 CTypedSimpleList(int nNextOffset = 0)
  : CSimpleList(nNextOffset) { }
 void AddHead(TYPE p)
  { CSimpleList::AddHead(p); }
 TYPE GetHead()
  { return (TYPE)CSimpleList::GetHead(); }
 TYPE GetNext(TYPE p)
  { return (TYPE)CSimpleList::GetNext(p); }
 BOOL Remove(TYPE p)
  { return CSimpleList::Remove((TYPE)p); }
 operator TYPE()
  { return (TYPE)CSimpleList::GetHead(); }
} ;

#endif

#include  " stdafx.h "
#include  " SimpleList.h "

CSimpleList::CSimpleList( int  nNextOffset)
{ 
 m_pHead = NULL; 
 m_nNextOffset = nNextOffset; 
}

void  CSimpleList::Construct( int  nNextOffset) 
{ 
 assert(m_pHead == NULL); 
 m_nNextOffset = nNextOffset; 
}

BOOL CSimpleList::IsEmpty()  const
{ 
 return m_pHead == NULL; 
}


void **  CSimpleList::GetNextPtr( void *  p)  const
{ 
 assert(p != NULL); 
 return (void**)((BYTE*)p+m_nNextOffset);   
//重点啊 配合下面的g_list.Construct(offsetof(CThreadData, pNext)); 一起看,然后画个图 是不是得到是pNext的位置
}


void  CSimpleList::RemoveAll()
{ 
 m_pHead = NULL; 
}


void *  CSimpleList::GetHead()  const
{ 
 return m_pHead; 
}

void *  CSimpleList::GetNext( void *  prevElement)  const
{ 
 return *GetNextPtr(prevElement); 
}

void  CSimpleList::AddHead( void *  p)
{
 assert(p != NULL);
 assert(*GetNextPtr(p) == NULL);

 *GetNextPtr(p) = m_pHead;
 m_pHead = p;
}

BOOL CSimpleList::Remove( void *  p)
{
 assert(p != NULL);

 if (m_pHead == NULL)
  return FALSE;

 BOOL bResult = FALSE;
 if (m_pHead == p)
 {
  m_pHead = *GetNextPtr(p);
  bResult = TRUE;
 }
 else
 {
  void* pTest = m_pHead;
  while (pTest != NULL && *GetNextPtr(pTest) != p)
   pTest = *GetNextPtr(pTest);
  if (pTest != NULL)
  {
   *GetNextPtr(pTest) = *GetNextPtr(p);
   bResult = TRUE;
  }
 }
 return bResult;
}

// 调用了

struct  CThreadData
{
 CThreadData* pNext; 
 int nCount;        
 LPVOID* pData;      
} ;


CTypedSimpleList < CThreadData *>  g_list;
int  main( int  argc,  char *  argv[])
{
 g_list.Construct(offsetof(CThreadData, pNext)); //得到pNext的和CThreadData的偏量
 CThreadData* pData=NULL,
 pData = new CThreadData;
 pData->nCount = 0;
 pData->pData = NULL;
 pData->pNext=NULL;
 g_list.AddHead(pData);

 pData = new CThreadData;
 pData->nCount = 1;
 pData->pData = NULL;
 pData->pNext=NULL;
 g_list.AddHead(pData);

 pData = new CThreadData;
 pData->nCount = 2;
 pData->pData = NULL;
 pData->pNext=NULL;
  
 g_list.AddHead(pData);

 pData=g_list;
 while(pData=g_list.GetNext(pData))
 {
      printf("%d\r\n",pData->nCount);
 }
.delete掉new出来的东西(略) 可以调Remove() 然后delete
}

 //下面是我自己根据这个原理写的stock和queue 最后用模版封装了一下

#ifndef __JONES_QUEUE__STOCK
#define  __JONES_QUEUE__STOCK

class  ListBase  // list基类
{
public:
 void Construct(int nNextOffset); //pNext的位移

protected:
 void** GetNextPtr(void* p) const; //利用位移得到pNext地址
 size_t m_nNextOffset; //偏移量
} ;


/**/ /********************************************************************/
/**/ /******************QueueList 先进先出********************************/
/**/ /********************************************************************/
class  QueueList :  public  ListBase
{
public:
 QueueList(int nNextOffset=0);

//操作
 bool empty() const;
 void* front() const; //得到栈的第一个数据
 void pop(); //出栈
 void push(void* p); //压栈
private:
 void* m_pHead; //头
 void* m_pTail; //尾
} ;


/**/ /********************************************************************/
/**/ /******************StockList 先进后出********************************/
/**/ /********************************************************************/
class  StockList :  public  ListBase
{
public:
 StockList(int nNextOffset=0);
 void pop(); //出栈
 void push(void* p); //压栈
 void* front() const; //得到栈的第一个数据
private:
 void* m_pHead; //头
} ;

/**/ /********************************************************************/
/**/ /*封装了一下 好看点而已(起码也用到模版了,现在流行的技术,呵呵..) */
/**/ /********************************************************************/
template  < typename TYPE,typename LISTTYPE = QueueList  /**/ /*list类型*/ >
class  SpecialList :  public  LISTTYPE
{
public:
 SpecialList(int nNextOffset=0)
  : LISTTYPE(nNextOffset)  {}

 TYPE front()
  { return (TYPE)LISTTYPE::front(); }

 void push(TYPE p)
  { LISTTYPE::push(p); }

} ;
#endif

// 调用的例子
struct  CThreadData
{
 CThreadData* pNext; 
 int nCount;     
 LPVOID* pData; 
} ;

SpecialList < CThreadData * ,QueueList >  g_Queue;

int  main( int  argc,  char *  argv[])
{ 
 g_Queue.Construct(offsetof(CThreadData, pNext));
 CThreadData* pData=NULL,*pTemp=NULL;
 pData = new CThreadData;
 pData->nCount = 0;
 pData->pData = NULL;
 pData->pNext=NULL;
 g_Queue.push(pData);

 pData = new CThreadData;
 pData->nCount = 1;
 pData->pData = NULL;
 pData->pNext=NULL;
 g_Queue.push(pData);

 pData = new CThreadData;
 pData->nCount = 2;
 pData->pData = NULL;
 pData->pNext=NULL; 
 g_Queue.push(pData);

 while(pData=g_Queue.front())
 {
  printf("%d\r\n",pData->nCount);
  g_Queue.pop();
  delete pData;
 }
 
  return 0;
}

最后忘了说还有1点就是 如果你用的是继承的数据
class  CNoTrackObject
{
public:
 virtual ~CNoTrackObject() {};

} ;

struct  CThreadData :  public  CNoTrackObject
{
 CThreadData* pNext; 
 int nCount;         
 LPVOID* pData;     )
} ;

那pNext位移的偏量就不是0了是4,具体可以查看<<c++对象模型>>