Sitr单链表迭代子类的实现

单链表迭代子类的实现：
template<typename T>
struct Sitr {
typedef T value_type; //T的别名；
typedef Snode<T> Node; //节点类型的别名； 
Node* me_; //结点指针me；
Sitr(Node* p = 0):me_(p){ } //构造函数；
Sitr(Sitr const& rhs):me_(rhs.me_){ } //拷贝构造函数；
Sitr& operator=(Sitr rhs) { //对赋值运算符=的重载；  
this->me_ = rhs.me_;
return *this;
}
T& operator*(void) { return me_->value_; } //对*重载； 
T* operator->(void) { return &(me_->value_);}//对->重载；
Sitr& operator++(void) { //++前缀；
me_ = me_->next_;
return *this;
}

/**********************************************/ 

符合STL规范的实现：
template<typename T>
struct Sitr
: std::iterator<std::forward_iterator_tag, T>
{
typedef Snode<T> Node;
Node* me_ ; //指向当前节点的指针；
Sitr(Node* p = 0) : me_(p) { }
T& operator*(void) { return me_->value_; }
T* operator->(void){ return &(me_->value_); }
bool operator!=(Sitr const& lhs) const
{ return me_ != lhs.me_; }
bool operator==(Sitr const& lhs) const
{ return me_ == lhs.me_; }
Sitr& operator++(void)
{ //前缀运算符；
me_ = me_->next_;
return *this;
}
Sitr operator++(int)
{ //后缀运算符；
Sitr tmp = *this;
++*this;
return tmp;
}
};
Sitr operator++(int) { //++后缀；
Sitr tmp = *this;
++*this;
return tmp;
}
bool operator!=(Sitr const& rhs) const //对！=重载；
{ return me_ != rhs.me_; }
bool operator==(Sitr const& rhs) const //对==重载；
{ return me_ == rhs.me_; }
};