关于迭代器的详细说明

关于迭代器的详细说明
1.迭代器是什么？
我们先从一个例子说起：
int a[10], *p;
for (p = &a[0]; p != &a[10], ++p) std::cout<< *p <<std::endl;
在上述for语句构成的迭代操作中，指针p首先指向了数组a的首元素，然后通过++运算和!=运算来完成迭代。

这里，指针p“知道”它指向了一片连续的存储区，所以++运算就有意义了。

这里，指针p可以视为一个最为简单的迭代器。

程序员可以通过该“迭代器”方便灵活地访问容器（即a数组）。

当然，这里所说的容器（a数组）过于简单。

对于更复杂的情况，迭代器被定义为一个某种容器类的伴随类，一般定义在容器类的内部，具有public属性，是其包围容器类的友元。

它可以在容器类的外部使用。

在多数情况下，迭代器内部有一个内部普通指针，它可以指向容器类的内部存储机构。

而迭代器类本身模拟了一个指针的行为，为此它重载了用于指针操作的三个关键运算符：
●!=
●++
●*
为了使用迭代器，其包围容器类提供了两个public成员：
●begin()，它返回一个迭代器对象，并使该对象的内部指针指向了容器对象的存储
结构的首元素；
●end()，它返回一个“空”迭代器对象，该对象的内部指针指往往是个nullptr。

而
在一般情况下，容器对象的内部存储结构都用nullptr标识存储的结尾，所以可
以说，空迭代器对象的内部指针指向了存储结构中最后一个元素的“后”一个元素。

这个迭代器对象往往称为“哨兵”。

注意：空迭代器仅仅参与了比较运算（及两个
迭代器内部指针的比较运算），而没有引用该迭代器对象“指向的对象”，因此在使
用上是安全的。

2.为什么需要迭代器
对于内部结构相对复杂的容器，我们不能使用指针直接指向其内部存储结构去访问它，因为这样直接破坏了数据封装的原则。

因此，一个折中的方法是为容器类设计一个遍历成员traverse()，它带有一个谓词函数作为参数去访问每一个容器元素。

然而，这虽然实现了数据封装，却是遍历这类的迭代操作变得很不灵活，因为程序员可能不得不编写多种谓词函数去处理不同的情况。

迭代器的引入可以彻底解决上述种种不便。

迭代器模拟了一个指针的行为，配合容器提供的begin()和end()，程序员可以像使用指针那样去使用迭代器，
而不需要直到容器的内部结构，也不需要编写太多的谓词函数，从而起到两全其美的效果。

3.如何定义迭代器
例如，对于教材上使用链式存储的容器类List，其迭代器的定义如下：
class list
{
public:
typedefint _elemType; //元素的类型
private:
struct _NODE_ //链表的节点。

这个用于存储的类型定义在private段中，因为类的外部无法获悉其存储结构的详情
{
_elemType data;
_NODE_* next;
} _head;
typedef _NODE_* _NODEPTR_;
public:
typedef _NODEPTR_ _range; //_range是_NODE_*的别名
//省略了其它容器成员
friend class iterator; //因为该迭代器类要访问List类的私有类型_NODE和其内部数据
class iterator
{
private:
_range _p; //迭代器的内部指针
public:
iterator(range = nullptr) : _p(range) {}
iterator& operator++()
{
_p = _p->next; //内部指针指向下一个节点。

根据容器类存储结构的不同，该语句也不尽相同
return *this;
}
bool operator!=(const iterator&i)
{
return _p != i._p; //两个指针的比较，判断两个指针是否指向了同一个节点
}
_elemType operator*()
{
return _p->data;
}
iterator& operator=(const iterator&i)
{
_p = i._p;
return *this;
}
};
iterator begin() const
{
return iterator(_head); //返回的迭代器对象（的内部指针）指向了容器存储结构的首元素
}
iterator end() const
{
return iterator(); //返回的迭代器对象（的内部指针）是nullptr
}
};
在使用迭代器时，就像使用指针那样方便：
List l{1, 2, 3, 4, 5};
List::iterator itr; //iterator是List类的内部类型，所以必须说明成这样。

注意：iterator类定义在public段中
for (itr = l.begin(); itr != l.end(); ++itr) std::cout<< *itr<<std::endl;
如果使用C++ 11标准，上述for语句还要更为简单：
for (auto e : l) std::cout<< e <<std::endl;
这条语句等价于：
for (List::iterator itr = l.begin(); itr != l.end(); ++itr)
{
_List::elemType e = *itr;
std::cout<< e <<std::endl;
}
4.伪迭代器
如果容器类的内部存储机构是类似于数组的、连续存储的线性结构，那么迭代器可以不用那么复杂：它可以不是一个类，而只是指针。

例如：
classVect
{
public:
typedefint _elemType;
typedef _elemType* _range;
private:
_range comp; //容器的内部存储是一片用new分配的指针内存，其行为类似于数组
size_tlen;
public:
typedef _range iterator; //由于知道容器是连续存储，因此不需要定义迭代器类，而只是为指针去一个迭代器别名
iterator begin() { return comp; } //返回的“迭代器”指向数组的首元素 iterator end() { return comp + len; } //comp + len - 1指向了数组的尾元素，而comp + len指向了改尾元素的“后”一个元素
//这里，编译器知道!=、++和*运算符作用于指针之上是什么含义，因此不需要重载这些运算符
};
这种伪迭代器的使用与真正迭代器的使用没有区别。

5.迭代器的种类
实际上，除了上述讲到的迭代器之外，容器类还有常量迭代器、反向迭代器等等，用于不同的场合。

更多的细节请查阅相关资料。