C++迭代器

迭代器是什么呢？迭代器就是可以以一个对象表现出容器元素的位置，实践这个概念的对象就是所谓的迭代器（结点的指针）。迭代器是一个可遍历STL所有元素的对象。 （遍历是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。）

迭代器对指针的一些基本操作如*、->、++、==、!=、=进行了重载，使其具有了遍历复杂数据结构的能力。

Opreator *：返回当前位置上的元素值。如果该元素拥有成员，可以通过迭代器以操作符->取用他们

Operator ++: 令迭代器前进至下一元素。大多数迭代器还可使用Operator--退至前一元素。 

Operator ==和！=: 判断两个迭代器是否指向同一个位置。 
Operator = 对迭代器赋值。

迭代器的成员函数：

所有容器类都提供一些成员函数使得迭代器能够遍历所有元素。

begin() 返回一个迭代器，指向容器起点，也就是第一元素的位置。 
end() 返回一个迭代器，指向容器终点。终点位于最末元素的下一位置。

先来简单实现一下它们：

我们来看一下一些基本操作的重载：

 

再来看一下其他功能的实现

template<class T>

class List

{

       typedefListNode<T> Node;

public:

       typedef__ListIterator<T> Iterator;

       List()

              :_head(newNode)

       {

              _head->_next= _head;

              _head->_prev= _head;

       }

 

       List(constT& x)

              :_head(newNode(x))

       {

              _head->_next= _head;

              _head->_prev= _head;

       }

       ~List()

       {

              Clear();

              delete_head;

              _head= NULL;

       }

       voidPushBack(const T& x)//增加一元素到链表尾

       {

              Node*tmp = new Node(x);

              Node*Prev = _head->_prev;

              Prev->_next= tmp;

              tmp->_prev = Prev;

 

              _head->_prev= tmp;

              tmp->_next= _head;

       }

       voidPushFront(const T& x)//增加一元素到链表头

       {

              Node*temp = new Node(x);

              Node*Next = _head->_next;

              Next->_prev= temp;

              temp->_next= Next;

 

              _head->_next= temp;

              temp->_prev= _head;

       }

       voidPopBack()//删除链表尾的一个元素

       {

              assert(_head->_next!= _head);

              Node*tmp = _head->_prev->_prev;

              Node*del = _head->_prev;

 

              tmp->_next= _head;

              _head->_prev= tmp;

 

              deletedel;

       }

       voidPopFront()//删除链表头的一个元素

       {

              assert(_head->_prev!= _head);

              Node*temp = _head->_next->_next;

              Node*dele = _head->_next;

 

              temp->_prev= _head;

              _head->_next= temp;

 

              deletedele;

       }

       IteratorErase(Iterator pos)//删除一个元素或一个区域的元素

       {

              assert(_head->_next!= _head);

              Node*del = pos._it;

              Node*Prev = del->_prev;

              Node*Next = del->_next;

              Prev->_next= Next;

              Next->_prev= Prev;

              deletedel;

              returnNext;

 

       }

       IteratorInserter(Iterator pos, const T& x)//在指定位置插入一个或多个元素

       {

              Node*tmp = new Node(x);

 

              Node*Prev = pos._it->_prev;

 

              Prev->_next= tmp;

              tmp->_prev= Prev;

 

              tmp->_next= pos._it;

              pos._it->_prev= tmp;

 

              returnpos;

       }

 

       IteratorBegin()//返回第一个元素的指针(iterator)

       {

              //returnIterator(_head->_next);

              return_head->_next;

       }

       IteratorEnd()//返回最后一个元素的下一位置的指针(list为空时end()=begin())

       {

              return_head;

       }

       Node*Back()//返回最后一元素的引用

       {

              return&(_head->_prev);

       }

       Node*Front()//返回第一个元素的引用

       {

        return &(_head->_next);

       }

       voidClear()//删除所有元素

       {

              Node*cur = _head->_next;

              Node*next = cur->_next;

              while(cur != _head)

              {

                     next= cur->_next;

                     deletecur;

                     cur= next;

              }

              _head->_next= _head;

              _head->_prev= _head;

       }

       boolEmpty()//判断是否链表为空

       {

              if(Begin() == End())

              {

                     return true;

              }

              return false;

       }

       size_tSize()//返回链表长度(size_t就是int型)

       {

              intcount = 0;

              Node*p = _head->_next;

              while(p )

              {

                     count++;

                     p= p->_next;

              }

              return count;

       }

      

private:

       Node*_head;

};

再去写自己想要实现的输出函数：

template<class T>

void PrintList(List<T>& l)

{}

在主函数中可以用a去调用实现各函数的功能：

       List<AA>a;

^_^欢迎大家指出其中的错误。