Dynamic package list

Written in front of the words:
authors from graduate has been involved in game development, with many games and practical case module code for all to study and exchange, hope the knowledge can bring some help, if you have any questions, please add group 641 792 143 exchanges and learning

#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_;
}