迭代器标准容器List

//完成标准容器List
#include<iostream>
using namespace std;
#pragma once
template<class T>
struct ListNode
{
  ListNode(const T& data = T())
  : _pPre(0)
  , _pNext(0)
  , _data(data)
  {}

  ListNode* _pPre;
  ListNode* _pNext;
  T _data;
};

template<class T, class Ref, class Ptr>
class ListIterator
{
  typedef ListIterator Self;
public:
  ListIterator()
    : _pCur(0)
  {}

  ListIterator(ListNode<T>* pCur)
    : _pCur(pCur)
  {}

  ListIterator(const Self& s)
    : _pCur(s._pCur)
  {}

  Ref operator*()
  {
    return _pCur->_data;
  }

  Ptr operator->()
  {
    return &(operator*());
    //return &(_pCur->_data); 
  }

  Self& operator++()
  {
    _pCur = _pCur->_pNext;
    return *this;
  }

  Self operator++(int)
  {
    Self temp(*this);
    _pCur = _pCur->_pNext;
    return temp;
  }

  Self& operator--()
  {
    _pCur = _pCur->_pPre;
    return*this;
  }

  Self operator--(int)
  {
    Self temp(*this);
    _pCur = _pCur->_pPre;
    return temp;
  }

  bool operator!=(const Self& s)
  {
    return _pCur != s._pCur;
  }

  bool operator==(const Self& s)
  {
    return _pCur == s._pCur;
  }

  ListNode<T>* _pCur;
};

template<class T>
class List
{
public:
  typedef ListIterator<T,T&,T*> Iterator;
  typedef ListNode<T> Node;
public:
  List()
    : _pHead(new Node)
  {
    _pHead->_pNext = _pHead;
    _pHead->_pPre = _pHead;
  }

  // 1 2 3 4 5 
  List(const T* array, size_t size)
    :_pHead(new ListNode<T>)
  {
    _pHead->_pNext = _pHead;
    _pHead->_pPre = _pHead;
    for (size_t i = 0; i < size; i++)
    {
      PushBack(array[i]);
    }
  }
  List(const List& l)
  {
    size_t size = l.Size();
    _pHead = new ListNode<T>;
    _pHead->_pNext = _pHead;
    _pHead->_pPre = _pHead;
    ListNode<T> *p = (l._pHead)->_pNext;
    for (size_t i = 0; i < size; i++)
    {
      PushBack(p->_data);
      p = p->_pNext;
    }
  }
  List& operator=(const List& l)
  {
    size_t size = l.Size();
    if (this != &l)
    {
      ListNode<T> *tmp = new ListNode<T>;
      tmp._pNext = tmp;
      tmp._pPre = tmp;
      ListNode<T> *p = l._pHead->_pNext;
      for (size_t i = 0; i < size; i++)
      {
        tmp.PushBack(p->_data);
        p = p->_pNext;
      }
      delete[] _pHead;
      _pHead = tmp;
    }
      return *this;
  }
  ~List()
  {
    Clear();
    delete[] _pHead;
    _pHead = NULL;
  }

    / 
  Iterator Begin()
  {
      return Iterator(_pHead->_pNext);
  }

  Iterator End()
  {
    return Iterator(_pHead);
  }
  /Modify// 
  void PushBack(const T& data)
  {
    ListNode<T> *pNewNode = new ListNode<T>(data);
    if (Empty())  //空链表
    {
      _pHead->_pNext = pNewNode;
      pNewNode->_pNext = _pHead;
      pNewNode->_pPre = _pHead;
      _pHead->_pPre = pNewNode;
    }
    else
    {
      ListNode<T> *pTail = _pHead->_pPre;
      pTail->_pNext = pNewNode;
      pNewNode->_pNext = _pHead;
      pNewNode->_pPre = pTail;
      _pHead->_pPre = pNewNode;
    }
  }

  void PopBack()
  {
    if (Empty())
    {
      return;
    }
    else
    {
      ListNode<T> *pTail = _pHead->_pPre->_pPre;
      delete pTail->_pNext;
      pTail->_pNext = _pHead;
      _pHead->_pPre = pTail;
    }
  }

  void PushFront(const T& data)
  {
    ListNode<T> *pNewNode = new ListNode<T>(data);
    pNewNode->_pNext = _pHead->_pNext;
    _pHead->_pNext->_pPre = pNewNode;
    _pHead->_pNext = pNewNode;
    pNewNode->_pPre = _pHead;
  }

  void PopFront()
  {
    if (Empty())
    {
      return;
    }
    else
    {
      ListNode<T> *p = _pHead->_pNext->_pNext;
      delete p->_pPre;
      p->_pPre = _pHead;
      _pHead->_pNext = p;
    }
  }

  Iterator Insert(Iterator pos, const T& data)
  {
    ListNode<T> *pNewNode = new ListNode<T>(data);
    pNewNode->_pNext = pos._pCur;
    pos._pCur->_pPre->_pNext = pNewNode;
    pNewNode->_pPre = pos._pCur->_pPre;
    pos._pCur->_pPre = pNewNode;

    return Iterator(pNewNode);
  }

  Iterator Erase(Iterator pos)
  {
    ListNode<T> *p = pos._pCur->_pNext;
    p->_pPre = pos._pCur->_pPre;
    pos._pCur->_pPre->_pNext = p;
    delete pos._pCur;
    return Iterator(p);
  }

  bool Empty()const
  {
    return _pHead == _pHead->_pNext;
  }

  size_t Size()const
  {
    size_t count = 0;
    ListNode<T> *p = _pHead->_pNext;
    ListNode<T> *q = _pHead;

    while (p != q)
    {
      count++;
      p = p->_pNext;
    }
    return count;

  /*  size_t count = 0;
    Iterator it = Begin();
    while (it != End())
    {
      count++;
      it++;
    }
    return count;*/
  }

  T& Front()
  {
    return _pHead->_pNext->_data;
  }
  const T& Front()const
  {
    return _pHead->_pNext->_data;
  }
  T& Back()
  {
    return _pHead->_pPre->_data;
  }
  const T& Back()const
  {
    return _pHead->_pPre->_data;
  }
  void Clear()
  {
    Iterator it = Begin();
    while (it != End())
    {
      it = Erase(it);
    }
    _pHead->_pNext = _pHead;
    _pHead->_pPre = _pHead;
  }
private:
  ListNode<T> *_pHead;
};

void test()
{
  int array[] = { 1, 2, 3, 4, 5 };
  List<int> l(array, sizeof(array)/sizeof(array[0]));
  //List<int> l1(l);
  List<int> l1 = l;
  /*l.PushBack(6);
  l.PushFront(0);*/

  /*l.PopBack();
  l.PopFront();*/
  //List<int>::Iterator p = l.Begin();
  //l.Insert(p, 0);
  //l.Erase(p);
  l.Clear();

  List<int>::Iterator it = l1.Begin();
  while (it!=l1.End())
  {
    cout << *it << "->";
    it++;
  }
  cout << "NULL" << endl;
  cout << l.Size() << endl;


}
int main()
{
  test();
  system("pause");
  return 0;
}