模拟实现STL中的list

#pragma once

#include<iostream>
using namespace std;
#include<assert.h>

template<class T>
struct __ListNode
{
__ListNode<T>* _prev;
__ListNode<T>* _next;
T _data;

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

template<class T,class Ref,class Ptr>
struct __ListIterator
{
typedef __ListNode<T> Node;
typedef __ListIterator<T, Ref, Ptr> Self;

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

__ListIterator()
{}

Node* _node;

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

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

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

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

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

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

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

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

template<class T>
class List
{
typedef __ListNode<T> Node;
public:
typedef __ListIterator<T, T&, T*> Iterator; //迭代器
typedef __ListIterator<T, const T&, const T*> ConstIterator; //const迭代器

Node* Buynode(const T&x)
{
Node* node = new Node(x);
return node;
}

List()
{
_head = Buynode(T());
_head->_next = _head;
_head->_prev = _head;
}

//void PushBack(const T&x)
//{
// Node* tail = _head->_prev;
// Node* tmp = Buynode(x);

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

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

void PushBack(const T&x)
{
Insert(End(),x);
}

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

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

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

void Insert(Iterator pos,const T&x) //在pos前面插入
{
Node* cur = pos._node;
Node* prev = cur->_prev; //在prev后面插入

Node* tmp = Buynode(x);
prev->_next = tmp->_next;
tmp->_prev = prev;

prev->_next = tmp;
tmp->_next = cur;
// tmp->_next = cur;
// cur->_prev = tmp;
//
// prev->_next = tmp;
// tmp->_prev = prev;
}

void Erase(Iterator pos) //在pos前面删除
{
assert(pos != End());
Node* cur = pos._node->_prev; //要删除的元素
Node* prev = cur->_prev;

prev->_next = cur->_next;
prev->_next = prev;
delete cur;
}

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

Iterator End()
{
return Iterator(_head);
}
private:
Node* _head;
};

void main()
{
//TestList();
List<int> l;

l.PushBack(1);
l.PushBack(2);
l.PushBack(3);
l.PushBack(4);

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