1、输入迭代器:只读,一次传递
为输入迭代器预定义实现只有istream_iterator和istreambuf_iterator,用于从一个输入流istream中读取。一个输入迭代器仅能对它所选择的每个元素进行一次解析,它们只能向前移动。一个专门的构造函数定义了超越末尾的值。总是,输入迭代器可以对读操作的结果进行解析(对每个值仅解析一次),然后向前移动。
2、输出迭代器:只写,一次传递
这是对输入迭代器的补充,不过是写操作而不是读操作。为输出迭代器的预定义实现只有ostream_iterator和ostreambuf_iterator,用于向一个输出流ostream写数据,还有一个一般较少使用的raw_storage_iterator。他们只能对每个写出的值进行一次解析,并且只能向前移动。对于输出迭代器来说,没有使用超越末尾的值来结束的概念。总之,输出迭代器可以对写操作的值进行解析(对每一个值仅解析一次),然后向前移动。
3、前向迭代器:多次读/写
前向迭代器包含了输入和输出迭代器两者的功能,加上还可以多次解析一个迭代器指定的位置,因此可以对一个值进行多次读/写。顾名思义,前向迭代器只能向前移动。没有为前向迭代器预定义迭代器。
4、双向迭代器:operator--
双向迭代器具有前向迭代器的全部功能。另外它还可以利用自减操作符operator--向后一次移动一个位置。由list容器中返回的迭代器都是双向的。
5、随机访问迭代器:类似于一个指针
随机访问迭代器具有双向迭代器的所有功能,再加上一个指针所有的功能(一个指针就是一个随机访问迭代器),除了没有一种“空(null)”迭代器和空指针对应。基本上可以这样说,一个随机访问迭代器就像一个指针那样可以进行任何操作,包括使用操作符operator[]进行索引,加某个数值到一个指针就可以向前或者向后移动若干个位置,或者使用比较运算符在迭代器之间进行比较。
迭代器类别 |
说明 |
输入 |
从容器中读取元素。输入迭代器只能一次读入一个元素向前移动,输入迭代器只支持一遍算法,同一个输入迭代器不能两遍遍历一个序列 |
输出 |
向容器中写入元素。输出迭代器只能一次一个元素向前移动。输出迭代器只支持一遍算法,统一输出迭代器不能两次遍历一个序列 |
正向 |
组合输入迭代器和输出迭代器的功能,并保留在容器中的位置 |
双向 |
组合正向迭代器和逆向迭代器的功能,支持多遍算法 |
随机访问 |
组合双向迭代器的功能与直接访问容器中任何元素的功能,即可向前向后跳过任意个元素 |
迭代器的操作:
每种迭代器均可进行包括表中前一种迭代器可进行的操作。迭代器的操作本质上是通过重载运算符来实现的,迭代器支持何种操作和能够执行什么运算是由迭代器所重载的运算符来决定的。
迭代器操作 |
说明 |
所有迭代器 |
|
p++ |
后置自增迭代器 |
++p |
前置自增迭代器 |
输入迭代器 |
|
*p |
复引用迭代器,作为右值 |
p=p1 |
将一个迭代器赋给另一个迭代器 |
p==p1 |
比较迭代器的相等性 |
p!=p1 |
比较迭代器的不等性 |
输出迭代器 |
|
*p |
复引用迭代器,作为左值 |
p=p1 |
将一个迭代器赋给另一个迭代器 |
正向迭代器 |
提供输入输出迭代器的所有功能 |
双向迭代器 |
|
--p |
前置自减迭代器 |
p-- |
后置自减迭代器 |
随机迭代器 |
|
p+=i |
将迭代器递增i位 |
p-=i |
将迭代器递减i位 |
p+i |
在p位加i位后的迭代器 |
p-i |
在p位减i位后的迭代器 |
p[i] |
返回p位元素偏离i位的元素引用 |
p |
如果迭代器p的位置在p1前,返回true,否则返回false |
p<=p1 |
p的位置在p1的前面或同一位置时返回true,否则返回false |
p>p1 |
如果迭代器p的位置在p1后,返回true,否则返回false |
p>=p1 |
p的位置在p1的后面或同一位置时返回true,否则返回false |
只有顺序容器和关联容器支持迭代器遍历,各容器支持的迭代器的类别如下:
容器 |
支持的迭代器类别 |
vector |
随机访问 |
deque |
随机访问 |
list |
双向 |
set |
双向 |
multiset |
双向 |
map |
双向 |
multimap |
双向 |
stack |
不支持 |
queue |
不支持 |
priority_queue |
不支持 |
现在我们将关注每种特定的迭代器如何使用。由于使用迭代器需要关于STL容器类和算法的知识。
一个指针也是一种迭代器。该程序同样显示了STL的一个主要特性——它不只是能够用于它自己的类类型,而且也能用于任何C或C++类型。Listing 1, iterdemo.cpp, 显示了如何把指针作为迭代器用于STL的find()算法来搜索普通的数组。
表 1. iterdemo.cpp
#include
#include
using namespace std;
#define SIZE 100
int iarray[SIZE];
int main()
{
iarray[20] = 50;
int* ip = find(iarray, iarray + SIZE, 50);
if (ip == iarray + SIZE)
cout << "50 not found in array" << endl;
else
cout << *ip << " found in array" << endl;
return 0;
}
在引用了I/O流库和STL算法头文件(注意没有.h后缀),该程序告诉编译器使用std名字空间。使用std名字空间的这行是可选的,因为可以删除该行对于这么一个小程序来说不会导致名字冲突。
程序中定义了尺寸为SIZE的全局数组。由于是全局变量,所以运行时数组自动初始化为零。下面的语句将在索引20位置处地元素设置为50,并使用find()算法来搜索值50:
iarray[20] = 50;
int* ip = find(iarray, iarray + SIZE, 50);
find()函数接受三个参数。头两个定义了搜索的范围。由于C和C++数组等同于指针,表达式iarray指向数组的第一个元素。而第二个参数iarray + SIZE等同于past-the-end 值,也就是数组中最后一个元素的后面位置。第三个参数是待定位的值,也就是50。find()函数返回和前两个参数相同类型的迭代器,这儿是一个指向整数的指针ip。
提示
必须记住STL使用模板。因此,STL函数自动根据它们使用的数据类型来构造。
为了判断find()是否成功,例子中测试ip和 past-the-end 值是否相等:
if (ip == iarray + SIZE) ...
如果表达式为真,则表示在搜索的范围内没有指定的值。否则就是指向一个合法对象的指针,这时可以用下面的语句显示::
cout << *ip << " found in array" << endl;
测试函数返回值和NULL是否相等是不正确的。不要象下面这样使用:
int* ip = find(iarray, iarray + SIZE, 50);
if (ip != NULL) ... // ??? incorrect
当使用STL函数时,只能测试ip是否和past-the-end 值是否相等。尽管在本例中ip是一个C++指针,其用法也必须符合STL迭代器的规则。
尽管C++指针也是迭代器,但用的更多的是容器迭代器。容器迭代器用法和iterdemo.cpp一样,但和将迭代器申明为指针变量不同的是,你可以使用容器类方法来获取迭代器对象。两个典型的容器类方法是begin()和end()。它们在大多数容器中表示整个容器范围。其他一些容器还使用rbegin()和rend()方法提供反向迭代器,以按反向顺序指定对象范围。
下面的程序创建了一个矢量容器(STL的和数组等价的对象),并使用迭代器在其中搜索。该程序和前一章中的程序相同。
Listing 2. vectdemo.cpp
#include
#include
#include
using namespace std;
vectorintVector(100);
void main()
{
intVector[20] = 50;
vector::iterator intIter =
find(intVector.begin(), intVector.end(), 50);
if (intIter != intVector.end())
cout << "Vector contains value " << *intIter << endl;
else
cout << "Vector does not contain 50" << endl;
}
注意用下面的方法显示搜索到的数据:
cout << "Vector contains value " << *intIter << endl;
和指针一样,你可以给一个迭代器赋值。例如,首先申明一个迭代器:
vector::iterator first;
该语句创建了一个vector
first = intVector.begin();
*first = 123;
这种赋值对于大多数容器类都是允许的,除了只读变量。为了防止错误赋值,可以申明迭代器为:
const vector::iterator result;
result = find(intVector.begin(), intVector.end(), value);
if (result != intVector.end())
*result = 123; // ???
警告
另一种防止数据被改变得方法是将容器申明为const类型。
『在VC中测试出错,正确的含义是result成为常量而不是它指向的对象不允许改变,如同int *const p;
输入迭代器是最普通的类型。输入迭代器至少能够使用==和!=测试是否相等;使用*来访问数据;使用++操作来递推迭代器到下一个元素或到达past-the-end 值。
为了理解迭代器和STL函数是如何使用它们的,现在来看一下find()模板函数的定义:
template
InputIterator find(
InputIterator first, InputIterator last, const T& value) {
while (first != last && *first != value) ++first;
return first;
}
注意
在find()算法中,注意如果first和last指向不同的容器,该算法可能陷入死循环。
输出迭代器缺省只写,通常用于将数据从一个位置拷贝到另一个位置。由于输出迭代器无法读取对象,因此你不会在任何搜索和其他算法中使用它。要想读取一个拷贝的值,必须使用另一个输入迭代器(或它的继承迭代器)。
Listing 3. outiter.cpp
#include
#include// Need copy()
#include// Need vector
using namespace std;
double darray[10] =
{1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9};
vectorvdouble(10);
int main()
{
vector::iterator outputIterator = vdouble.begin();
copy(darray, darray + 10, outputIterator);
while (outputIterator != vdouble.end()) {
cout << *outputIterator << endl;
outputIterator++;
}
return 0;
}
注意
当使用copy()算法的时候,你必须确保目标容器有足够大的空间,或者容器本身是自动扩展的。
前推迭代器能够读写数据值,并能够向前推进到下一个值。但是没法递减。replace()算法显示了前推迭代器的使用方法。
template
void replace (ForwardIterator first,
ForwardIterator last,
const T& old_value,
const T& new_value);
使用replace()将[first,last]范围内的所有值为old_value的对象替换为new_value。:
replace(vdouble.begin(), vdouble.end(), 1.5, 3.14159);
双向迭代器要求能够增减。如reverse()算法要求两个双向迭代器作为参数:
template
void reverse (BidirectionalIterator first,
BidirectionalIterator last);
使用reverse()函数来对容器进行逆向排序:
reverse(vdouble.begin(), vdouble.end());
随机访问迭代器能够以任意顺序访问数据,并能用于读写数据(不是const的C++指针也是随机访问迭代器)。STL的排序和搜索函数使用随机访问迭代器。随机访问迭代器可以使用关系操作符作比较。
random_shuffle() 函数随机打乱原先的顺序。申明为:
template
void random_shuffle (RandomAccessIterator first,
RandomAccessIterator last);
使用方法:
random_shuffle(vdouble.begin(), vdouble.end());
要学会使用迭代器和容器以及算法,需要学习下面的新技术。
本书的很多例子程序使用I/O流语句来读写数据。例如:
int value;
cout << "Enter value: ";
cin >> value;
cout << "You entered " << value << endl;
对于迭代器,有另一种方法使用流和标准函数。理解的要点是将输入/输出流作为容器看待。因此,任何接受迭代器参数的算法都可以和流一起工作。
Listing 4. outstrm.cpp
#include
#include// Need random(), srandom()
#include// Need time()
#include// Need sort(), copy()
#include// Need vector
using namespace std;
void Display(vector& v, const char* s);
int main()
{
// Seed the random number generator
srandom( time(NULL) );
// Construct vector and fill with random integer values
vectorcollection(10);
for (int i = 0; i < 10; i++)
collection[i] = random() % 10000;;
// Display, sort, and redisplay
Display(collection, "Before sorting");
sort(collection.begin(), collection.end());
Display(collection, "After sorting");
return 0;
}
// Display label s and contents of integer vector v
void Display(vector& v, const char* s)
{
cout << endl << s << endl;
copy(v.begin(), v.end(),
ostream_iterator(cout, "/t"));
cout << endl;
}
函数Display()显示了如何使用一个输出流迭代器。下面的语句将容器中的值传输到cout输出流对象中:
copy(v.begin(), v.end(),
ostream_iterator(cout, "/t"));
第三个参数实例化了ostream_iterator
$ g++ outstrm.cpp
$ ./a.out
Before sorting
677 722 686 238 964 397 251 118 11 312
After sorting
11 118 238 251 312 397 677 686 722 964
这是STL神奇的一面『确实神奇』。为定义输出流迭代器,STL提供了模板类ostream_iterator。这个类的构造函数有两个参数:一个ostream对象和一个string值。因此可以象下面一样简单地创建一个迭代器对象:
ostream_iterator(cout, "/n")
该迭代起可以和任何接受一个输出迭代器的函数一起使用。
插入迭代器用于将值插入到容器中。它们也叫做适配器,因为它们将容器适配或转化为一个迭代器,并用于copy()这样的算法中。例如,一个程序定义了一个链表和一个矢量容器:
listdList;
vectordVector;
通过使用front_inserter迭代器对象,可以只用单个copy()语句就完成将矢量中的对象插入到链表前端的操作:
copy(dVector.begin(), dVector.end(), front_inserter(dList));
三种插入迭代器如下:
· 普通插入器 将对象插入到容器任何对象的前面。
· Front inserters 将对象插入到数据集的前面——例如,链表表头。
· Back inserters 将对象插入到集合的尾部——例如,矢量的尾部,导致矢量容器扩展。
使用插入迭代器可能导致容器中的其他对象移动位置,因而使得现存的迭代器非法。例如,将一个对象插入到矢量容器将导致其他值移动位置以腾出空间。一般来说,插入到象链表这样的结构中更为有效,因为它们不会导致其他对象移动。
Listing 5. insert.cpp
#include
#include
#include
using namespace std;
int iArray[5] = { 1, 2, 3, 4, 5 };
void Display(list& v, const char* s);
int main()
{
listiList;
// Copy iArray backwards into iList
copy(iArray, iArray + 5, front_inserter(iList));
Display(iList, "Before find and copy");
// Locate value 3 in iList
list::iterator p =
find(iList.begin(), iList.end(), 3);
// Copy first two iArray values to iList ahead of p
copy(iArray, iArray + 2, inserter(iList, p));
Display(iList, "After find and copy");
return 0;
}
void Display(list& a, const char* s)
{
cout << s << endl;
copy(a.begin(), a.end(),
ostream_iterator(cout, " "));
cout << endl;
}
运行结果如下:
$ g++ insert.cpp
$ ./a.out
Before find and copy
5 4 3 2 1
After find and copy
5 4 1 2 3 2 1
可以将front_inserter替换为back_inserter试试。
如果用find()去查找在列表中不存在的值,例如99。由于这时将p设置为past-the-end 值。最后的copy()函数将iArray的值附加到链表的后部。
在涉及到容器和算法的操作中,还有两个迭代器函数非常有用:
· advance() 按指定的数目增减迭代器。
· distance() 返回到达一个迭代器所需(递增)操作的数目。
例如:
listiList;
list::iterator p =
find(iList.begin(), iList.end(), 2);
cout << "before: p == " << *p << endl;
advance(p, 2); // same as p = p + 2;
cout << "after : p == " << *p << endl;
int k = 0;
distance(p, iList.end(), k);
cout << "k == " << k << endl;
advance()函数接受两个参数。第二个参数是向前推进的数目。对于前推迭代器,该值必须为正,而对于双向迭代器和随机访问迭代器,该值可以为负。
使用 distance()函数来返回到达另一个迭代器所需要的步骤。
注意
distance()函数是迭代的,也就是说,它递增第三个参数。因此,你必须初始化该参数。未初始化该参数几乎注定要失败。