【C++】双向线性链表容器的实现

// 双向线性链表容器
#include <cstring>
#include <iostream>
#include <stdexcept>
using namespace std;

// 链表类模板
template<typename T>
class List
{
public:
  // 构造、析构、支持深拷贝的拷贝构造和拷贝赋值
  List(void) : m_head(NULL), m_tail(NULL) {}
  ~List(void)
  {
    clear();
  }

  List(List const& that) : m_head(NULL), m_tail(NULL)
  {
    for (Node* node = that.m_head; node != NULL;
          node = node->m_next)
      push_back(node->m_data);
  }

  List& operator = (List const& rhs) 
  {
    if (&rhs != this)
    {
      List list(rhs);
      swap(m_head, list.m_head);
      swap(m_tail, list.m_tail);
    }
    return *this;
  }

  // 获取首元素
  T& front(void) 
  {
    if (empty())
      throw underflow_error("链表下溢！

"); //下溢异常
    return m_head->m_data;
  }

  T const& front(void) const 
  {
    return const_cast<List*>(this)->front();
  }

  // 向首部压入
  void push_front(T const& data) 
  {
    m_head = new Node(data, NULL, m_head);
    if (m_head->m_next != NULL)
      m_head->m_next->m_prev = m_head;
    else
      m_tail = m_head;
  }

  // 从首部弹出
  void pop_front(void) 
  {
    if (empty())
      throw underflow_error("链表下溢！

");
    Node* next = m_head->m_next;
    delete m_head;
    m_head = next;
    if (m_head)
      m_head->m_prev = NULL;
    else
      m_tail = NULL;
  }

  // 获取尾元素
  T& back(void)
  {
    if (empty())
      throw underflow_error("链表下溢！");
    return m_tail->m_data;
  }

  T const& back(void) const 
  {
    return const_cast<List*>(this)->back();
  }
  
  // 向尾部压入
  void push_back(T const& data) 
  {
    m_tail = new Node(data, m_tail);
    if (m_tail->m_prev != NULL)
      m_tail->m_prev->m_next = m_tail;
    else
      m_head = m_tail;
  }

  // 从尾部弹出
  void pop_back(void) 
  {
    if (empty())
      throw underflow_error("链表下溢！

");
    Node* prev = m_tail->m_prev;
    delete m_tail;
    m_tail = prev;
    if (m_tail != NULL)
      m_tail->m_next = NULL;
    else
      m_head = NULL;
  }

  // 删除全部匹配元素
  void remove(T const& data) 
  {
    for (Node* node = m_head, *next; node != NULL; 
        node = next)
    {
      next = node->m_next;
      if (equal(data, node->m_data))
      {
        if (node->m_prev != NULL)
          node->m_prev->m_next = node->m_next;
        else
          m_head = node->m_next;

        if (node->m_next)
          node->m_next->m_prev = node->m_prev;
        else
          m_tail = node->m_prev;

        delete node;
      }
    }
  }

  // 清空
  void clear(void) 
  {
    while (!empty())
      pop_back();
  }

  // 判空
  bool empty(void) const 
  {
    return NULL == m_head &&  NULL == m_tail;
  }

  // 大小
  size_t size(void) const 
  {
    size_t nodes = 0;
    for (Node* node = m_head; node != NULL;
        node = node->m_next)
      ++nodes;
    return nodes;
  }

  // 下标运算符————SHIT!
  T& operator[] (size_t i)
  {
    for (Node* node = m_head; node != NULL;
        node = node->m_next)
      if (0 == i--)
        return node->m_data;
    throw out_of_range("下标越界！");
  }

  T const& operator[] (size_t i) const
  {
    return const_cast<List&>(*this)[i];
  }

  // 插入输出流
  friend ostream& operator << (ostream& os, 
        List const& list) 
  {
    for (Node* node = list.m_head; node != NULL;
        node = node->m_next)
      os << *node;
    return os;
  }

private:
  // 节点类模板
  class Node
  {
  public:
    Node(T const& data, Node* prev = NULL, Node* next = NULL)
      : m_data(data), m_prev(prev), m_next(next) {}
    friend ostream& operator << (ostream& os, Node const& node)
    {
      return os << '[' << node.m_data << ']';
    }
    T   m_data; // 数据
    Node* m_prev; // 前指针
    Node* m_next; // 后指针
  };

  // 推断元素是否相等
  bool equal(T const & a, T const& b) const
  {
    return a == b;
  }

  Node* m_head; // 头指针
  Node* m_tail; // 尾指针
public:
  // 正向迭代器
  class Iterator
  {
  public:
    Iterator(Node* head = NULL, Node* tail = NULL, Node* node = NULL) 
      : m_head(head), m_tail(tail), m_node(node) {}
    bool operator == (Iterator const& rhs) const
    {
      return m_node == rhs.m_node;
    }

    bool operator != (Iterator const& rhs) const
    {
      return ! (*this == rhs);
    }

    Iterator& operator++ (void)
    {
      if (m_node)
        m_node = m_node->m_next;
      else
        m_node = m_head;
      return *this;
    }
    
    Iterator const operator++ (int)
    {
      Iterator old = *this;
      ++*this;
      return old;
    }

    Iterator& operator-- (void)
    {
      if (m_node)
        m_node = m_node->m_prev;
      else
        m_node = m_tail;
      return *this;
    }
    
    Iterator const operator-- (int)
    {
      Iterator old = *this;
      --*this;
      return old;
    }

    T& operator* (void) const
    {
      return m_node->m_data;
    }

    T* operator->(void) const
    {
      return &**this;
    }
  private:
    Node* m_head;
    Node* m_tail;
    Node* m_node;
    friend class List;
  };

  // 获取起始正向迭代器————指向第一个元素
  Iterator begin(void)
  {
    return Iterator(m_head, m_tail, m_head);
  }

  // 获取终止正向迭代器————指向最后一个元素的下一个位置
  Iterator end(void)
  {
    return Iterator(m_head, m_tail);
  }

  // 在正向迭代器前插入，返回指向新插入元素的迭代器
  Iterator insert(Iterator loc, T const& data)
  {
    if (loc == end())
    {
      push_back(data);
      return Iterator(m_head, m_tail, m_tail);
    }
    else
    {
      Node* node = new Node(data, loc.m_node->m_prev, loc.m_node);
      if (node->m_prev)
        node->m_prev->m_next = node;
      else
        m_head = node;
      node->m_next->m_prev = node;
      return Iterator(m_head, m_tail, node);
    }
  }

  // 删除迭代器所指向的元素。并返回该元素之后的迭代器
  Iterator erase(Iterator loc)
  {
    if (loc == end())
      throw invalid_argument("无效參数！");
    if (loc.m_node->m_prev)
      loc.m_node->m_prev->m_next = loc.m_node->m_next;
    else
      m_head = loc.m_node->m_next;
    if (loc.m_node->m_next)
      loc.m_node->m_next->m_prev = loc.m_node->m_prev;
    else
      m_tail = loc.m_node->m_prev;
    Node* next = loc.m_node->m_next;
    delete loc.m_node;
    return Iterator(m_head, m_tail, next);
  }

  // 常正向迭代器
  // 反向迭代器
  // 常反向迭代器

};

// 针对char const* 类型的成员特化版本号
template<>
bool List<char const*>::equal(char const* const& a, char const* const& b) const
{
  return (0 == strcmp(a, b));
}