利用c++模板实现单链表

/* SList.hpp */

#ifndef _SLIST_H_
#define _SLIST_H_

#include <iostream>

using namespace std;

template<typename T>
struct Node
{
	T m_Data;
	Node<T> *m_pNext;
	Node()
	{
		m_pNext = NULL;
	}
};

template<typename T>
class CSList
{
public:
	CSList();
	~CSList();
	//尾插法
	bool AppendNode(T Data);
	//删除
	bool DelNode(T key);
	//修改
	bool ModNode(T key, T New);
	//查找
	bool FindNode(T key);
	//逆序
	bool Reverse();
	//打印
	void Print();
	//销毁
	void Clear();
private:
	Node<T> *m_pFirst;
};

template<typename T>
CSList<T>::CSList()
{
	m_pFirst = NULL;
}

template<typename T>
CSList<T>::~CSList()
{
	Node<T> *pCurNode = NULL;
	pCurNode = m_pFirst;
	while(pCurNode)
	{
		m_pFirst = m_pFirst->m_pNext;
		delete pCurNode;
		pCurNode = m_pFirst;
	}
}

template<typename T>
bool CSList<T>::AppendNode(T Data)
{
	Node<T> *pNewNode = new Node<T>;
	Node<T> *pCurNode = NULL;
	if(!pNewNode)
	{
		return false;
	}
	pNewNode->m_Data = Data;
	pNewNode->m_pNext = NULL;
	if(!m_pFirst)
	{
		m_pFirst = pNewNode;
		return true;
	}
	pCurNode = m_pFirst;
	while(pCurNode->m_pNext)
	{
		pCurNode = pCurNode->m_pNext;
	}
	pCurNode->m_pNext = pNewNode;
	return true;
}

template<typename T>
bool CSList<T>::DelNode(T Key)
{
	Node<T> *pPrevNode = NULL;
	Node<T> *pCurNode = NULL;
	if(!m_pFirst)
	{
		return false;
	}
	if(m_pFirst->m_Data == Key)
	{
		pCurNode = m_pFirst;
		m_pFirst = m_pFirst->m_pNext;
		delete pCurNode;
		pCurNode = NULL;
		return true;
	}
	pPrevNode = m_pFirst;
	pCurNode = m_pFirst->m_pNext;
	while(pCurNode->m_Data)
	{
		if(pCurNode->m_Data == Key)
		{
			pPrevNode->m_pNext = pCurNode->m_pNext;
			delete pCurNode;
			return true;
		}
		pPrevNode = pCurNode;
		pCurNode = pCurNode->m_pNext;
	}
	return false;
}

template<typename T>
bool CSList<T>::ModNode(T key, T New)
{
	Node<T> *pCurNode = NULL;
	if(!m_pFirst)
	{
		return false;
	}
	pCurNode = m_pFirst;
	while(pCurNode)
	{
		if(pCurNode->m_Data == key)
		{
			pCurNode->m_Data = New;
			return true;
		}
		pCurNode = pCurNode->m_pNext;
	}
	return false;
}

template<typename T>
bool CSList<T>::FindNode(T key)
{
	Node<T> *pCurNode = NULL;
	if(!m_pFirst)
	{
		return false;
	}
	pCurNode = m_pFirst;
	while(pCurNode)
	{
		if(pCurNode->m_Data == key)
		{
			return true;
		}
		pCurNode = pCurNode->m_pNext;
	}
	return false;
}

template<typename T>
bool CSList<T>::Reverse()
{
	Node<T> *pPrevNode = NULL;
	Node<T> *pCurNode = m_pFirst;
	Node<T> *pNext = NULL;
	while(pCurNode)
	{
		pNext = pCurNode->m_pNext;
		pCurNode->m_pNext = pPrevNode;
		pPrevNode = pCurNode;
		pCurNode = pNext;
	}
	m_pFirst = pPrevNode;
	return true;
}

template<typename T>
void CSList<T>::Print()
{
	Node<T> *pCurNode = m_pFirst;
	while(pCurNode)
	{
		cout<<pCurNode->m_Data<<"\t";
		pCurNode = pCurNode->m_pNext;
	}
	cout<<endl;
}

template<typename T>
void CSList<T>::Clear()
{
	Node<T> *pCurNode = NULL;
	pCurNode = m_pFirst;
	while(pCurNode)
	{
		m_pFirst = m_pFirst->m_pNext;
		delete pCurNode;
		pCurNode = m_pFirst;
	}
}

#endif

/* main.cpp */

#include <iostream>
#include "SList.hpp"

int main()
{
	CSList<int> IntList;
	IntList.AppendNode(1);
	IntList.AppendNode(7);
	IntList.AppendNode(4);
	IntList.AppendNode(2);
	IntList.AppendNode(8);
	IntList.AppendNode(5);
	IntList.AppendNode(9);
	IntList.AppendNode(6);
	IntList.AppendNode(3);
	IntList.Print();
	IntList.Reverse();
	IntList.Print();
	IntList.DelNode(3);
	IntList.DelNode(1);
	IntList.DelNode(2);
	IntList.Print();
	return 0;
}