c++ 双向链表代码

#ifndef __LIST_H__
#define __LIST_H__

 

#include "ListIterator.h"

namespace xxx

{
 template <typename T>
 struct ListNode_t
 {
  T    m_value;
  ListNode_t * m_pPrevious;
  ListNode_t * m_pNext;
 };

 /** @addtogroup 基础件
 * 
 *  @{
 */

 /** @addtogroup 容器
 * 
 *  @{
 */

 /*!
 * @brief 列表
 */
 template <typename T>
 class List_t
 {
 public:
  typedef ListNode_t <T>    NodeType;   //!< 节点类型
  typedef ListIterator_t <T>   Iterator;   //!< 迭代器
  typedef ListReverseIterator_t <T> ReverseIterator; //!< 反向迭代器

 private:
  NodeType * m_pFirst;
  NodeType* m_pLast;
  int   m_iCount;

 public:
  /*!
  * @brief 构造函数
  */
  List_t(void);

  /*!
  * @brief 析构函数
  */
  virtual ~List_t(void);

  /*!
  * @brief 添加一个元素
  */
  Iterator Append(const T &value);

  /*!
  * @brief 添加另一个列表的所有元素
  */
  void Append(const List_t <T> &ls);

  /*!
  * @brief 拷贝另一个列表的所有元素
  */
  List_t<T>& operator =(const List_t <T> &ls);

  /*!
  * @brief 获得起始迭代器
  */
  Iterator Begin() const;

  /*!
  * @brief 获得结束迭代器
  */
  Iterator End() const;

  /*!
  * @brief 获得第一个元素的迭代器
  */
  Iterator First() const;

  /*!
  * @brief 获得最后一个元素的迭代器
  */
  Iterator Last() const;

  /*!
  * @brief 获得反向起始迭代器
  */
  ReverseIterator RBegin() const;

  /*!
  * @brief 获得反向结束迭代器
  */
  ReverseIterator REnd() const;

  /*!
  * @brief 获得反向第一个元素的迭代器
  */
  ReverseIterator RFirst() const;

  /*!
  * @brief 获得反向最后一个元素的迭代器
  */
  ReverseIterator RLast() const;

  /*!
  * @brief 获得元素数量
  */
  inline int Count() const {  return m_iCount;  }

  /*!
  * @brief 在指定位置插入元素
  */
  Iterator Insert(Iterator it, const T &value);

  /*!
  * @brief 在指定位置插入元素
  */
  void Insert(int idx, const T &value);

  /*!
  * @brief 在指定位置插入元素
  */
  void Insert(Iterator it, const T *pItems, int iCount);

  /*!
  * @brief 在指定位置插入另一个列表的所有元素
  */
  void Insert(Iterator it, List_t &ls);

  /*!
  * @brief 移除指定值的元素
  */
  Iterator RemoveV(const T& value);

  /*!
  * @brief 移除指定位置的元素
  */
  Iterator Remove(Iterator it);

  /*!
  * @brief 移除指定位置的元素
  */
  Iterator Remove(int idx);

  /*!
  * @brief 移除指定范围的元素
  */
  Iterator Remove(Iterator b, Iterator e);

  /*!
  * @brief 查找指定值的元素的位置
  */
  Iterator Find(const T &value);

  /*!
  * @brief 反向查找指定值的元素的位置
  */
  ReverseIterator ReverseFind(const T& value);

  /*!
  * @brief 清空所有元素
  */
  void Clear();

  /*!
  * @brief 获得指定位置的元素
  */
  T& operator [](int index);

  /*!
  * @brief 在尾部添加一个元素
  */
  void PushBack(const T& value);

  /*!
  * @brief 在前部添加一个元素
  */
  void PushFront(const T& value);

  /*!
  * @brief 从尾部弹出一个元素
  */
  T PopBack();

  /*!
  * @brief 从前部弹出一个元素
  */
  T PopFront();
 };

 /** @} */ // end of 容器

 /** @} */ // end of 基础件

 template <typename T>
 List_t<T>::List_t(void)
 {
  m_pFirst = m_pLast = 0;
  m_iCount = 0;
 }

 template <typename T>
 List_t<T>::~List_t(void)
 {
  Clear();
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::Append(const T &value)
 {
  return Insert(End(), value);
 }

 template <typename T>
 void List_t<T>::Append(const List_t<T> &ls)
 {
  Iterator it = ls.Begin();

  while(it != ls.End())
  {
   Append(*it);
   it++;
  }
 }

 template <typename T>
 List_t<T>& List_t<T>::operator =(const List_t<T> &ls)
 {
  if(this != &ls)
  {
   Clear();

   Iterator it = ls.Begin();

   while(it != ls.End())
   {
    Append(*it);
    it++;
   }
  }

  return *this;
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::Begin() const
 {
  return Iterator(m_pFirst);
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::End() const
 {
  return Iterator(0);
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::First() const
 {
  return Iterator(m_pFirst);
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::Last() const
 {
  return Iterator(m_pLast);
 }

 template <typename T>
 typename List_t<T>::ReverseIterator List_t<T>::RBegin() const
 {
  return ReverseIterator(m_pLast);
 }

 template <typename T>
 typename List_t<T>::ReverseIterator List_t<T>::REnd() const
 {
  return ReverseIterator(0);
 }

 template <typename T>
 typename List_t<T>::ReverseIterator List_t<T>::RFirst() const
 {
  return ReverseIterator(m_pLast);
 }

 template <typename T>
 typename List_t<T>::ReverseIterator List_t<T>::RLast() const
 {
  return ReverseIterator(m_pFirst);
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::Insert(typename List_t<T>::Iterator it, const T &value)
 {
  NodeType *pNode = new NodeType;

  pNode->m_value = value;
  pNode->m_pNext = it.m_pNode;

  if (it.m_pNode != 0)
  {
   pNode->m_pPrevious = it.m_pNode->m_pPrevious;

   if (it.m_pNode->m_pPrevious != 0)
   {
    it.m_pNode->m_pPrevious->m_pNext = pNode;
   }

   it.m_pNode->m_pPrevious = pNode;
  }
  else
  {
   if (m_pLast != 0)
   {
    m_pLast->m_pNext = pNode;
   }

   pNode->m_pPrevious = m_pLast;
   m_pLast = pNode;
  }

  if (m_pFirst == it.m_pNode)
  {
   m_pFirst = pNode;
  }

  m_iCount++;
  return Iterator(pNode);
 }

 template <typename T>
 void List_t<T>::Insert(int idx, const T &value)
 {
  Iterator it = Begin();

  while(idx-- > 0) it++;
  Insert(it, value);
 }

 template <typename T>
 void List_t<T>::Insert(typename List_t<T>::Iterator it, const T *pItems, int iCount)
 {
  for (int i = 0; i < iCount; i++)
  {
   it = Insert(it, pItems[i]);
   it++;
  }
 }

 template <typename T>
 void List_t<T>::Insert(typename List_t<T>::Iterator it, List_t<T> &ls)
 {
  typename List_t::Iterator _it = ls.Begin();

  while(_it != ls.End())
  {
   it = Insert(it, *_it);
   it++;
   _it++;
  }
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::RemoveV(const T& value)
 {
  Iterator it = Find(value);

  if (it != End())
  {
   return Remove(it);
  }
  return it;
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::Remove(typename List_t<T>::Iterator it)
 {
  Iterator itNext = it;
  ++itNext;

  if (it.m_pNode->m_pNext != 0)
  {
   it.m_pNode->m_pNext->m_pPrevious = it.m_pNode->m_pPrevious;
  }
  else
  {
   if (it.m_pNode == m_pLast)
   {
    m_pLast = it.m_pNode->m_pPrevious;
   }
  }

  if (it.m_pNode->m_pPrevious != 0)
  {
   it.m_pNode->m_pPrevious->m_pNext = it.m_pNode->m_pNext;
  }
  else
  {
   if (it.m_pNode == m_pFirst)
   {
    m_pFirst = it.m_pNode->m_pNext;
   }
  }

  delete it.m_pNode;
  m_iCount--;

  return itNext;
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::Remove(int idx)
 {
  Iterator it = Begin();

  while(idx-- > 0) it++;
  return Remove(it);
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::Remove(typename List_t<T>::Iterator b, typename List_t<T>::Iterator e)
 {
  while(b != e)
  {
   Iterator n;

   n = b;
   n++;
   Remove(b);
   b = n;
  }
  return e;
 }

 template <typename T>
 typename List_t<T>::Iterator List_t<T>::Find(const T &value)
 {
  Iterator it = Begin();

  while(it != End())
  {
   if (*it == value)
   {
    break;
   }

   it++;
  }

  return it;
 }

 template <typename T>
 typename List_t<T>::ReverseIterator List_t<T>::ReverseFind(const T &value)
 {
  ReverseIterator it = RBegin();

  while(it != REnd())
  {
   if (*it == value)
   {
    break;
   }

   it++;
  }

  return it;
 }

 template <typename T>
 void List_t<T>::Clear()
 {
  while(Count())
  {
   Remove(Begin());
  }
 }

 template <typename T>
 T & List_t<T>::operator [](int index)
 {
  int i;
  Iterator it = Begin();

  for (i = 0; i < index; i++)
  {
   it++;
  }

  return *it;
 }

 template <typename T>
 void List_t<T>::PushBack(const T &value)
 {
  Insert(End(), value);
 }

 template <typename T>
 void List_t<T>::PushFront(const T &value)
 {
  Insert(Begin(), value);
 }

 template <typename T>
 T List_t<T>::PopBack()
 {
  T v = m_pLast->m_value;
  Remove(Iterator(m_pLast));
  return v;
 }

 template <typename T>
 T List_t<T>::PopFront()
 {
  T v = m_pFirst->m_value;
  Remove(Iterator(m_pFirst));
  return v;
 }
}

#endif