STL泛型编程之迭代器
前言
学习《C++ Primer Plus》中泛型编程的一些概念，感觉需要对这部分的知识理解的深一点(都是书上的内容，只不过经常搞不清，所以就抄了个笔记)。STL提供了一组表示容器、迭代器、函数对象和算法的模板。容器是一个与数组类似的单元，可以存储若干个值。STL容器是同质的，即存储的值的类型相同；算法是完成特定任务的“处方”；迭代器能够用来遍历容器的对象，与能够遍历数组的指针类似，是广义指针；函数对象是类似于函数的对象，可以是类对象或函数指针(包括函数名，因为函数名被用作指针)。
泛型编程
面向对象编程关注的是编程的数据方面，而泛型编程关注的是算法。它们之间的共同点是抽象和创建可重用代码，但它们的理念绝然不同。
泛型编程旨在编写独立于数据类型的代码。在C++中，完成通用程序的工具是模板。当然，模板使得能够按泛型定义函数或类，而STL通过通用算法更进一步。模板让这一切成为可能，但必须对元素进行仔细地设计。为解模板和设计师如何协同工作的，来看一看需要迭代器的原因。
理解迭代器是理解STL的关键所在。模板使得算法独立于存储的数据类型，而迭代器使算法独立于使用的容器类型。因此，它们都是STL通用方法的重要组成部分。
为了理解为何需要迭代器，我们来看如何为两种不同数据表示实现find函数，然后看如何推广这种方法。首先看一个在double数组中搜索特定值的函数，可以这样编写该函数:
double* find_ar(double *ar, int n, const double &val)
{
for(int i = 0; i < n; i++)
{
if(ar[i] == val)
return &ar[i];
}
return 0;
}如果函数在数组中找到这样的值，则返回该值在数组中的位地址，否则返回一个空指针。该函数使用下标来遍历数组。可以用模板将这种算法推广到包含==运算符、任意类型的数组。尽管如此，这种算法仍然与一种特定的数据结构(数组)关联在一起。
下面来看搜索链表的情况。链表有链接在一起的Node结构组成：
struct Node
{
double item;
Node *p_next;
};假设有一个指向链表第一个节点的指针，每个节点的p_next指针都指向下一个节点，链表最后一个节点的p_next指针被设置为0，则可以这样编写find_ll()函数：
Node* find_ll(Node *head, const double &val)
{
Node *start;
for(start = head; start != 0; start = start->p_next)
{
if(start->item == val)
return start;
}
return 0;
}
同样，也可以使用模板将这种算法推广到支持==运算符的任何数据类型的链表。然而，这种算法也是与特定的数据结构(链表)相关联在一起。
从实现的细节上看，这两个find函数的算法时不同的：一个使用数组索引来遍历元素，另一个则将start重置为start->p_next。但从广义上讲，这两种算法是相同的：将值依次与容器中的每个值进行比较，直到找到匹配的为止。
泛型编程旨在使用同一个find函数来处理数组、链表或任何其他的容器。即函数不仅独立于容器中存储的数据类型，而且独立于容器本身的数据结构。模板提供了存储在容器中的数据类型的通用表示，因此还需要遍历容器中的值的通用表示，迭代器正是这样的通用表示。
要实现find函数，迭代器应具备的特征如下：
(1)应能够对迭代器执行解除引用的操作，以便能访问它引用的值。即如果p是一个迭代器，则应该对*p进行定义。
(2)应能够将一个迭代器赋给另一个。即如果p和q都是迭代器，则应对表达式p = q进行定义。
(3)应能够将一个迭代器与另一个进行比较，看它们是否相等。即如果p和q都是迭代器，则应该对p == q和p != q进行定义。
(4)应能够使用迭代器遍历容器中的所有元素，这可以通过为迭代器p定义++p和p++来实现。
迭代器也可以完成其他的操作，但有上述功能就足够了，至少对于find函数是如此。实际上，STL按功能的强弱定义了多种级别的迭代器。
顺便说一句，常规指针就能满足迭代器的要求，因此，可以这样重新编写find_arr()函数：
typedef double *iterator;
iterator find_ar(iterator ar, int n, const double &val)
{
for(int i = 0; i < n; i++, ar++)
{
if(*ar == val)
return ar;
}
return 0;
}然后可以修改函数参数，使之接受两个指示区间的指针参数，其中的一个指向数组的起始位置，另一个指向数组的超尾；同时函数可以通过返回尾指针，来指出没有找到要找的值。下面的find_arr()版本完成了这些修改：
typedef double *iterator;
iterator find_ar(iterator begin, iterator end, const double &val)
{
iterator ar;
for(ar =begin; ar != end; i++, ar++)
{
if(*ar == val)
return ar;
}
return end;
}
对于find_ll()函数，可以定义一个迭代器类，其中定义了运算符*和++：
struct Node
{
double item;
Node *p_next;
};
class iterator
{
Node *pt;
public:
iterator():pt(0) {}
iterator(Node *pn):pt(pn) {}
double operator*() {return pt->item;}
iterator &operator++()
{
pt = pt->p_next;
return *this;
}
iterator operator++(int)
{
iterator tmp = *this;
pt = pt->p_next;
return tmp;
}
};这里重点不是如何定义iterator类，而是有了这样的类后，第二个find函数就可以这样编写：
iterator find_ll(iterator head, const double &val)
{
iterator start;
for(start = head; start != 0; ++start)
{
if(*start == val)
return start;
}
return 0;
}这和find_ar()几乎相同，差别在于如何到达最后一个值。find_ar()函数使用超尾迭代器，而find_ll()使用存储在最后一个节点中的空值。除了这种差别外，这两个函数完全相同。例如，可以要求链表的最后一个元素后面还有一个额外的元素，即让数组和链表都有超尾元素，并在迭代器达超尾位置时结束搜索。这样，find_ar()和find_ll()监测数据尾的方式将相同，从而成为相同的算法。注意，增加超尾元素后，对迭代器的要求变成了对容器的要求。
STL遵循上面介绍的方法。首先，每个容器类(vector、llist、deque等)定义了相应的迭代器类型。对于其中的某个类，迭代器可能是指针；而对于另一个类，则可能是对象。不管实现方式如何，迭代器都将提供所需的操作，如*和++(有些类需要的操作可能比其他类多)。其次，每个容器类都有一个超尾标记，当迭代器递增到超越容器的最后一个值后，这个值将被赋给迭代器。每个容器类都有begin()和end()方法，它们分别返回一个指向容器的第一个元素和超尾位置的迭代器。每个容器类都使用++操作，让迭代器从指向第一个元素逐步指向超尾位置，从而遍历容器中的每一个元素。
使用容器类时，无需知道其迭代器是如何实现的，也无需知道超尾是如何实现的，而只需知道它有迭代器，其begin()返回一个指向第一个元素的迭代器，end()返回一个指向超尾位置的迭代器即可。例如，假设要打印vector
vector::iterator pr;
for(pr = scores.begin(); pr != scores.end(); pr++)
{
cout << *pr < 其中，下面的代码行将pr的类型声明为vector
vectorclass:
vector::iterator pr; 如果要使用list
list::iterator pr;
for(pr = scores.begin(); pr!= scores.end(); pr++)
{
cout << *pr < 唯一不同的是pr的类型。因此，STL通过为每个类定义适当的迭代器，并以统一的风格设计类，能够对内部表示绝然不同的容器，编写相同的代码。使用C++11新增的自动类型推断可进一步简化：对于矢量或列表，都可使用如下代码：
for(auto pr = scores.begin(); pr != scores.end(); pr++)
{
cout << *pr <实际上，作为一种编程风格，最好避免直接使用迭代器，而应尽可能使用STL函数(如for_each())来处理细节。也可以使用C++11新增的基于范围的for循环：
for(auto x : scores) cout << x << endl;来总结一下STL方法。首先是处理容器的算法，应尽可能用通用的术语来表达算法，使之独立于数据类型和数据类型。为使通用算法能够适用于具体情况，应定义能够满足算法需求的迭代器，并把要求加到容器设计上。即基于算法的要求，设计基本迭代器的特征和容器特征。