迭代器模式及STL中迭代器概念

迭代器模式的基本概念是：提供对聚合类对象的统一访问，而无需关心对象内部的数据组织方式。

UML描述

图片来自：（http://www.cnblogs.com/jqbird/archive/2011/08/31/2160653.html）

抽象迭代器接口定义了统一的访问方式：First(第一个对象), Next（下一个对象），IsDone（是否访问完毕），具体迭代器类定义中包含聚合类对象的引用或者指针，在实现接口中定义的方法时，通过对象的引用或者指针去遍历集合的对象。

这个可以结合STL的迭代器概念来说明，对于每一种容易，其遍历方式是不一样的，所以每一个容器都有其专属的访问方式，在每一个专属迭代器的定义中，有针对具体类似于next方法（比如对+，++操作符的操作起到的效果与此类似）的实现。

迭代器定义：

// TEMPLATE CLASS iterator
template<class _Category,
	 class _Ty,
	 class _Diff = ptrdiff_t,
	 class _Pointer = _Ty *,
	 class _Reference = _Ty&>
	
struct iterator
{	// base type for all iterator classes
	typedef _Category iterator_category;
	typedef _Ty value_type;
	typedef _Diff difference_type;
	typedef _Diff distance_type;	// retained
	typedef _Pointer pointer;
	typedef _Reference reference;
};

在通用迭代器的定义中，有如下几种数据类型必须要说明（用于描述迭代器本身的类型信息）：
value type:指迭代器所指对象的类型
difference_type 表示迭代器之间的距离类型
pointer: 所指对象的指针类型
reference：所指对象的引用类型
category: 迭代器类型：如：
只读（Iput Iterator）：不允许修改指向的对象
只写(Output Iterator)：只允许写
可读可写(Forward Iterator)：允许读写
可双向移动迭代器（Bidirectional Iterator）：支持迭代器的双向移动，可前进可后退。
随机访问迭代器（Random Access Iterator）：支持迭代器的随机访问

 

结合vector迭代器的定义，我们分析一下具体的代码：

template<class _Myvec>
class _Vector_iterator
: public _Vector_const_iterator<_Myvec>
{	// iterator for mutable vector
public:
	typedef _Vector_iterator<_Myvec> _Myiter;        //当前具体的迭代器类型
	typedef _Vector_const_iterator<_Myvec> _Mybase;  

        //迭代器的相关属性描述：特性萃取剂通过该信息获取迭代器的相关信息
	typedef random_access_iterator_tag iterator_category;
	typedef typename _Myvec::value_type value_type;
	typedef typename _Myvec::difference_type difference_type;
	typedef typename _Myvec::pointer pointer;
	typedef typename _Myvec::reference reference;

        //构造函数
	_Vector_iterator()
		{	// construct with null vector pointer
		}

	_Vector_iterator(pointer _Parg, const _Container_base *_Pvector)
		: _Mybase(_Parg, _Pvector)
		{	// construct with pointer _Parg
		}

	
        //典型操作符重载，以支持迭代器对数据的访问、迭代器的移动
	reference operator*() const
		{	// return designated object
		return ((reference)**(_Mybase *)this);
		}

	pointer operator->() const
		{	// return pointer to class object
		return (&**this);
		}

	_Myiter& operator++()
		{	// preincrement
		++*(_Mybase *)this;
		return (*this);
		}

	_Myiter& operator--()
		{	// predecrement
		--*(_Mybase *)this;
		return (*this);
		}

	_Myiter& operator+=(difference_type _Off)
		{	// increment by integer
		*(_Mybase *)this += _Off;
		return (*this);
		}

	_Myiter operator+(difference_type _Off) const
		{	// return this + integer
		_Myiter _Tmp = *this;
		return (_Tmp += _Off);
		}

	_Myiter operator-(difference_type _Off) const
		{	// return this - integer
		_Myiter _Tmp = *this;
		return (_Tmp -= _Off);
		}

        //下表操作：进行迭代器偏移后解引用
	reference operator[](difference_type _Off) const
		{	// subscript
		return (*(*this + _Off));
		}

        ......
	};

转载于:https://my.oschina.net/myspaceNUAA/blog/78774