CTypedSimpleList类模板

// CTypedSimpleList.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"


#include<windows.h>
#include <process.h>
#include <iostream>
#include <stddef.h>
using namespace std;

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

// 提供给用户的接口函数（Operations），用于添加、删除和遍历节点
    BOOL IsEmpty() const;
    void AddHead(void* p);
    void RemoveAll();
    void* GetHead() const;
    void* GetNext(void* p) const;
    BOOL Remove(void* p);

// 为实现接口函数所需的成员（Implementation）
    void* m_pHead;        // 链表中第一个元素的地址
    size_t m_nNextOffset;    // 数据结构中pNext成员的偏移量
    void** GetNextPtr(void* p) const;
};

// 类的内联函数
inline CSimpleList::CSimpleList(int nNextOffset)
{ m_pHead = NULL; m_nNextOffset = nNextOffset; }
inline void CSimpleList::Construct(int nNextOffset)
{ m_nNextOffset = nNextOffset; }
inline BOOL CSimpleList::IsEmpty() const
{ return m_pHead == NULL; }
inline void CSimpleList::RemoveAll()
{ m_pHead = NULL; }
inline void* CSimpleList::GetHead() const
{ return m_pHead; }
inline void* CSimpleList::GetNext(void* preElement) const
{ return *GetNextPtr(preElement); }
inline void** CSimpleList::GetNextPtr(void* p) const
{ return (void**)((BYTE*)p + m_nNextOffset); }

void CSimpleList::AddHead(void* p)
{
    *GetNextPtr(p) = m_pHead;
    m_pHead = p;
}

BOOL CSimpleList::Remove(void* p)
{
    if(p == NULL)    // 检查参数
        return FALSE;
    
    BOOL bResult = FALSE; // 假设移除失败
    if(p == m_pHead)
    {
    // 要移除头元素
        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;
}

template<class TYPE>
class CTypedSimpleList : public CSimpleList
{
public:
    CTypedSimpleList(int nNextOffset = 0) 
        : CSimpleList(nNextOffset) { }
    void AddHead(TYPE p) 
        { CSimpleList::AddHead((void*)p); }
    TYPE GetHead()
        { return (TYPE)CSimpleList::GetHead(); }
    TYPE GetNext(TYPE p)
        { return (TYPE)CSimpleList::GetNext(p); }
    BOOL Remove(TYPE p)
        { return CSimpleList::Remove(p); }
    operator TYPE()
        { return (TYPE)CSimpleList::GetHead(); }
};


struct MyThreadData
{
    MyThreadData* pNext;
    int nSomeData;
};

void main()
{
    MyThreadData* pData;
    CTypedSimpleList<MyThreadData*> list;
    list.Construct(offsetof(MyThreadData, pNext));

    // 向链表中添加成员
    for(int i=0; i<10; i++)
    {
        pData = new MyThreadData;
        pData->nSomeData = i;
        list.AddHead(pData);
    }

    // …………   // 使用链表中的数据

    // 遍历整个链表，释放MyThreadData对象占用的空间
    pData = list;  // 调用了成员函数 operator TYPE()，相当于“pData = list.GetHead();”语句
    while(pData != NULL)
    {
        MyThreadData* pNextData = pData->pNext;
        printf(" The value of nSomeData is: %d \n", pData->nSomeData);
        delete pData;
        pData = pNextData;
    }
    system("pause");
}