c++ stl list 迭代器简单实现

#include<iostream.h>

template<class T>
class node
{
public:
T data;
void * pre;
void * next;
};

template<class T>
class iter
{
public:
typedef node<T> * lnode;
lnode pnode;
iter(iter<T>& a):pnode(a.pnode){}
iter(){}
iter(lnode a):pnode(a){}

T & operator *() const {return (pnode->data);}
T * operator ->()const {return &(operator *());}
bool operator !=(iter<T> & a )const {return pnode != a.pnode; }
bool operator ==(iter<T> & a )const {return pnode == a.pnode; }
iter<T> & operator++() {pnode=(lnode)pnode->next; return *this;}
iter<T> & operator--() {pnode=(lnode)pnode->pre; return *this;}
iter<T> operator--(int) {iter<T> tmp=*this; --*this;return tmp;}
iter<T> operator++(int) {iter<T> tmp=*this; ++*this;return tmp;}
};

template<class T>
class test
{
public:
typedef iter<T> iterator;
typedef node<T> * lp;
public:
test(T a);
test();
~test();
iterator first();
iterator end();
void insert(T a);
void clear();
private:
lp p;
};

template<class T>
test<T>::test(T a)
{
lp tmp=new node<T>;
tmp->data=a;
tmp->pre=NULL;
tmp->next=p;

node<T> *tmpp=(node<T> *)p->pre;
tmpp->next=tmp;
}

template<class T>
test<T>::test()
{
p= new node<T>;
p->pre=p;
p->next=p;
}

template<class T>
test<T>::~test()
{
delete p;
}

template<class T>
void test<T>::clear()
{
lp tmp=NULL;
lp root=p;
while(p->next != root)
{
tmp=(lp)p->next;
delete p;
p=tmp;
}
}

template<class T>
void test<T>::insert(T a)
{
node<T> *tmp=new node<T>;
tmp->data=a;
tmp->pre=NULL;
tmp->next=p;

node<T> *tmpp=(node<T> *)p->pre;
tmpp->next=tmp;
p->pre=tmp;
}

template<class T>
typename test<T>::iterator test<T>::first()
{
return (lp)p->next;
}

template<class T>
typename test<T>::iterator test<T>::end()
{
return p;
}

int main()
{
test<int> a;
a.insert(99);
a.insert(10);
a.insert(93);
a.insert(29);
a.insert(59);
a.insert(69);
a.insert(79);
a.insert(66);
a.insert(340);
a.insert(0);
a.insert(330);
test<int>::iterator i,ii;
i=a.first();
ii=a.end();
while(i != ii)
{
cout<<*i<<endl;
i++;
}
a.clear();
return 0;
}