STL-模拟实现List

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

using namespace std;

template<typename T>
struct ListNode
{
ListNode* _next;
ListNode* _prev;
T _data;

ListNode(const T& x)
:_data(x)
, _next(NULL)
, _prev(NULL)
{}
};

template<typename T, typename Ref, typename Ptr>  //迭代器
struct ListIterator
{

typedef ListNode<T> Node;
typedef ListIterator<T, Ref, Ptr> Self;

Node* _node;

ListIterator(){}
ListIterator(Node* node)
:_node(node)
{}

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

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

Ptr operator->()
{
return &(_node->_data);
}

Self& operator++()
{
_node = _node->_next;
return *this;
}

Self operator++(int)
{
Self tmp(*this);
_node = _node->_next;
return tmp;
}

Self& operator--()
{
_node = _node->_prev;
return *this;
}

Self operator--(int)
{
Self tmp(*this);
_node = _node->_prev;
return tmp;
}
};

template<typename T>
class List
{
typedef ListNode<T> Node;
public:
typedef ListIterator<T, T&, T*> Iterator;
typedef ListIterator<T, const T&, const T*> ConstIterator;
public:
List()
:_head(BuyNewNode(T()))
{
_head->_next = _head;
_head->_prev = _head;
}
~List()
{
Node* tmp = _head->_next;

while (tmp != _head)
{
delete tmp->_prev;
tmp=tmp->_next;
}
_head = NULL;
}

void PushBack(const T& x)
{
//Node* tmp = BuyNewNode(x);

//_head->_prev->_next = tmp;
//tmp->_prev = _head->_prev;

//_head->_prev= tmp;
//tmp->_next = _head;

Insert(End(),x);
}

void PopBack()
{
Erase(--End());
}

void PushFront(const T& x)
{
Insert(Begin(), x);
}

void PopFront()
{
Erase(Begin());
}

Iterator Insert(Iterator pos, const T& x)
{
assert(pos._node);

Node* cur = pos._node;
Node* prev = cur->_prev;

Node* tmp = BuyNewNode(x);

prev->_next = tmp;
tmp->_prev = prev
99b4
;

tmp->_next = cur;
cur->_prev = tmp;

return tmp;
}

Iterator Erase(Iterator pos)
{
assert(pos._node && pos._node != _head);

Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;

prev->_next = next;
next->_prev = prev;

delete cur;
cur = NULL;

return next;
}

Iterator Begin()
{
//return Iterator(_head->_next);
return _head->_next;
}

Iterator End()
{
return Iterator(_head);
}

ConstIterator Begin()const
{
return ConstIterator(_head->_next);
}

ConstIterator End()const
{
return ConstIterator(_head);
}
protected:
Node* _head;

private:
Node* BuyNewNode(const T& x)
{
//次处应该是空间配置器
return new Node(x);
}
};