动态链表封装

写到前面的话:
作者从毕业开始一直从事游戏开发,提供大量游戏实战模块代码及案例供大家学习与交流,希望以下知识可以带来一些帮助,如有任何疑问，请加群641792143交流与学习

#include <assert.h>
#include <iostream>

using namespace  std;

template<typename T>
class Node
{
public:
	Node()
	{
	}
	inline operator T& ()
	{
		return data_;
	}

	T data_;
	Node<T>* prev_;
	Node<T>* next_;
	
};

template <typename T>
class List
{
	List()
	{
		first_node_ = last_node_ = NULL;
		count_ = 0;
	}

	virtual ~List()
	{
		clear();
	}

	inline Node<T>* first()
	{
		return first_node_;
	}

	inline Node<T>* last()
	{
		return last_node_;
	}

	inline int count() const
	{
		return count_;
	}

	//清空链表
	virtual void clear()
	{
		Node<T>* pNode = first_node_;
		Node<T>* pNextNode;

		while(pNode) 
		{
			pNextNode = pNode->next_;
			freeNode(pNode); //一直释放头结点
			pNode = pNextNode;
		}
		first_node_ = last_node_ = NULL;
		count_ = 0;
	}
	
	//在node节点的前面插入新节点
	//如果node为空则表示插入到链表的起始位置
	Node<T>* linkBefore(const T& data,Node<T>* node = NULL)
	{
		if(!node)
			node = first_node_;

		Node<T>* pPrev = node ? node->prev_ : NULL;
		Node<T>* new_node = allocNode();

		new_node->data_ = data;
		new_node->prev_ = pPrev;
		new_node->next_ = node;

		if(pPrev)
			pPrev->next_ = new_node;
		else
			first_node_ = new_node;

		if(node)
			node->prev_ = new_node;
		else
			last_node_ = new_node;

		count_++;
		return new_node;
	}

	//
	Node<T>* linkAfter(const T& data,Node<T>* pNode = NULL)
	{
		if(!pNode)
			pNode = last_node_;

		Node<T>* pNext = pNode ? pNode->next_ : NULL;
		Node<T>* pNewNode = allocNode();

		pNewNode->data_ = data;
		pNewNode->prev_ = pNode;
		pNewNode->next_ = pNext;

		if(pNext)
			pNext->prev_ = pNewNode;
		else
			last_node_ = pNewNode;

		if(pNode)
			pNode->next_ = pNewNode;
		else
			first_node_ = pNewNode;

		count_++;

		return pNewNode;
	}

	//在node节点的前面插入新节点
	//如果node为空则表示插入到链表的起始位置
	Node<T>* linkBefore(Node<T>* new_node,Node<T>* node = NULL)
	{
		if(!node)
			node = first_node_;

		Node<T>* pPrev = node ? node->prev_ : NULL;

		new_node->prev_ = pPrev;
		new_node->next_ = node;

		if(pPrev)
			pPrev->next_ = new_node;
		else
			first_node_ = new_node;

		if(node)
			node->prev_ = new_node;
		else
			last_node_ = new_node;

		count_++;

		return new_node;
	}

	Node<T>* Transfer(Node<T>* pNewNode,Node<T>* pNode = NULL)
	{
		if(!pNode)
			pNode = last_node_;

		Node<T>* pNext = pNode ? pNode->next_ : NULL;

		pNewNode->prev_ = pNode;
		pNewNode->next_ = pNext;

		if(pNext)
			pNext->prev_ = pNewNode;
		else
			last_node_ = pNewNode;

		if(pNode)
			pNode->next_ = pNewNode;
		else
			first_node_ = pNewNode;

		count_++;

		return pNewNode;
	}

	//将数据插入到链表头部
	inline Node<T>* linkAtFirst(const T& data)
	{
		return linkBefore(data,first_node_);
	}

	inline Node<T>* TransferAtLast(Node<T>* pNewNode)
	{
		return Transfer(pNewNode,last_node_);
	}

	//通过索引获取链表节点
	Node<T>* getNodeAt(int index)
	{
		assert(index > -1 && index < count_)

		for(Node<T>* pNode = first_node_;pNode;pNode = pNode->next_)
		{
			if(index <= 0)
				return pNode;

			index--;
		}

		return NULL;
	}

	//移除一个节点
	inline void remove(Node<T>* node,bool free_flag = true)
	{
		if(node)
		{
			//移除节点
			if(node->prev_)
				node->prev_->next_ = node->next_;

			if(node->next_)
				node->next_->prev_ = node->prev_;

			if(node == first_node_)
				first_node_ = node->next_;

			if(node == last_node_)
				last_node_ = node->prev_;

			if(free_flag)
				freeNode(node);

			count_--;
		}
	}


protected:

	virtual Node<T>* allocNode()
	{
		return new Node<T>;
	}

	virtual void freeNode(Node<T>* pNode)
	{
		if(pNode)
		{
			delete pNode;
			pNode = NULL;
		}
	}

private:
	Node<T>* first_node_;
	Node<T>* last_node_;
	int count_;
}