Fredanf / STL / C++ 迭代器 基础介绍

分享

   

C++ 迭代器 基础介绍

2012-11-28  Fredanf

C++ 迭代器 基础介绍

迭代器提供对一个容器中的对象的访问方法,并且定义了容器中对象的范围。迭代器就如同一个指针。事实上,C++的指针也是一种迭代器。但是,迭代器不仅仅是指针,因此你不能认为他们一定具有地址值。例如,一个数组索引,也可以认为是一种迭代器。

除了使用下标来访问 vector 对象的元素外,标准库还提供了另一种访问元素的方法:使用迭代器(iterator)。迭代器是一种检查容器内元素并遍历元素的数据类型。

标准库为每一种标准容器(包括 vector)定义了一种迭代器类型。迭代器类型提供了比下标操作更通用化的方法:所有的标准库容器都定义了相应的迭代器类型,而只有少数的容器支持下标操作。因为迭代器对所有的容器都适用,现代 C++ 程序更倾向于使用迭代器而不是下标操作访问容器元素,即使对支持下标操作的 vector 类型也是这样。

容器的 iterator 类型

每种容器类型都定义了自己的迭代器类型,如 vector

     vector<int>::iterator iter;

这符语句定义了一个名为 iter 的变量,它的数据类型是 vector<int> 定义的 iterator 类型。每个标准库容器类型都定义了一个名为 iterator 的成员,这里的 iterator 与迭代器实际类型的含义相同。

术语:迭代器和迭代器类型

程序员首次遇到有关迭代器的术语时可能会困惑不解,原因之一是由于同一个术语 iterator 往往表示两个不同的事物。一般意义上指的是迭代器的概念;而具体而言时指的则是由容器定义的具体的 iterator 类型,如 vector<int>

重点要理解的是,有许多用作迭代器的类型,这些类型在概念上是相关的。若一种类型支持一组确定的操作(这些操作可用来遍历容器内的元素,并访问这些元素的值),我们就称这种类型为迭代器。

各容器类都定义了自己的 iterator 类型,用于访问容器内的元素。换句话说,每个容器都定义了一个名为 iterator 的类型,而这种类型支持(概念上的)迭代器的各种操作。

begin end 操作

每种容器都定义了一对命名为 begin end 的函数,用于返回迭代器。如果容器中有元素的话,由 begin 返回的迭代器指向第一个元素:

     vector<int>::iterator iter = ivec.begin();

上述语句把 iter 初始化为由名为 vector 操作返回的值。假设 vector 不空,初始化后,iter 即指该元素为 ivec[0]

end 操作返回的迭代器指向 vector 的“末端元素的下一个”。“超出末端迭代器”(off-the-end iterator)。表明它指向了一个不存在的元素。如果 vector 为空,begin 返回的迭代器与 end 返回的迭代器相同。

 

end 操作返回的迭代器并不指向 vector 中任何实际的元素,相反,它只是起一个哨兵(sentinel)的作用,表示我们已处理完 vector 中所有元素。

vector 迭代器的自增和解引用运算

迭代器类型定义了一些操作来获取迭代器所指向的元素,并允许程序员将迭代器从一个元素移动到另一个元素。

迭代器类型可使用解引用操作符(dereference operator)(*)来访问迭代器所指向的元素:

     *iter = 0;

解引用操作符返回迭代器当前所指向的元素。假设 iter 指向 vector 对象 ivec 的第一元素,那么 *iter ivec[0] 就是指向同一个元素。上面这个语句的效果就是把这个元素的值赋为 0

迭代器使用自增操作符向前移动迭代器指向容器中下一个元素。从逻辑上说,迭代器的自增操作和 int 型对象的自增操作类似。对 int 对象来说,操作结果就是把 int 型值“加 1”,而对迭代器对象则是把容器中的迭代器“向前移动一个位置”。因此,如果 iter 指向第一个元素,则 ++iter 指向第二个元素。

由于 end 操作返回的迭代器不指向任何元素,因此不能对它进行解引用或自增操作。

迭代器的其他操作

另一对可执行于迭代器的操作就是比较:用 == != 操作符来比较两个迭代器,如果两个迭代器对象指向同一个元素,则它们相等,否则就不相等。

迭代器应用的程序示例

假设已声明了一个 vector<int> 型的 ivec 变量,要把它所有元素值重置为 0,可以用下标操作来完成:

   // reset all the elements in ivec to 0

   for (vector<int>::size_type ix = 0; ix != ivec.size(); ++ix)

             ivec[ix] = 0;

上述程序用 for 循环遍历 ivec 的元素,for 循环定义了一个索引 ix ,每循环迭代一次 ix 就自增 1for 循环体将 ivec 的每个元素赋值为 0

更典型的做法是用迭代器来编写循环:

   // equivalent loop using iterators to reset all the elements in ivec to 0

for (vector<int>::iterator iter = ivec.begin();iter != ivec.end(); ++iter)

         *iter = 0;  // set element to which iter refers to 0

 

for 循环首先定义了 iter,并将它初始化为指向 ivec 的第一个元素。for 循环的条件测试 iter 是否与 end 操作返回的迭代器不等。每次迭代 iter 都自增 1,这个 for 循环的效果是从 ivec 第一个元素开始,顺序处理 vector 中的每一元素。最后, iter 将指向 ivec 中的最后一个元素,处理完最后一个元素后,iter 再增加 1,就会与 end 操作的返回值相等,在这种情况下,循环终止。

for 循环体内的语句用解引用操作符来访问当前元素的值。和下标操作符一样,解引用操作符的返回值是一个左值,因此可以对它进行赋值来改变它的值。上述循环的效果就是把 ivec 中所有元素都赋值为 0

通过上述对代码的详细分析,可以看出这段程序与用下标操作符的版本达到相同的操作效果:从 vector 的第一个元素开始,把 vector 中每个元素都置为 0

本节给出的例子程序,如果 vector 为空,程序是安全的。如果 ivec 为空,则 begin 返回的迭代器不指向任何元素——由于没有元素,所以它不能指向任何元素。在这种情况下,从 begin 操作返回的迭代器与从 end 操作返回的迭代器的值相同,因此 for 语句中的测试条件立即失败。

const_iterator

前面的程序用 vector::iterator 改变 vector 中的元素值。每种容器类型还定义了一种名为 const_iterator 的类型,该类型只能用于读取容器内元素,但不能改变其值。

当我们对普通 iterator 类型解引用时,得到对某个元素的非 const2.5 节)。而如果我们对 const_iterator 类型解引用时,则可以得到一个指向 const 对象的引用(2.4 节),如同任何常量一样,该对象不能进行重写。

例如,如果 text vector<string> 类型,程序员想要遍历它,输出每个元素,可以这样编写程序:

   // use const_iterator because we won't change the elements

  for (vector<string>::const_iterator iter = text.begin();iter != text.end(); ++iter)

  cout << *iter << endl; // print each element in text

除了是从迭代器读取元素值而不是对它进行赋值之外,这个循环与前一个相似。由于这里只需要借助迭代器进行读,不需要写,这里把 iter 定义为 const_iterator 类型。当对 const_iterator 类型解引用时,返回的是一个 const 值。不允许用 const_iterator: 进行赋值

     for (vector<string>::const_iterator iter = text.begin();iter != text.end(); ++ iter)

      *iter = " ";     // error: *iter is const

 

使用 const_iterator 类型时,我们可以得到一个迭代器,它自身的值可以改变,但不能用来改变其所指向的元素的值。可以对迭代器进行自增以及使用解引用操作符来读取值,但不能对该元素赋值。

不要把 const_iterator 对象与 const iterator 对象混淆起来。声明一个 const 迭代器时,必须初始化迭代器。一旦被初始化后,就不能改变它的值:

  vector<int> nums(10);  // nums is nonconst

  const vector<int>::iterator cit = nums.begin();

  *cit = 1;  // ok: cit can change its underlying element

   ++cit;  // error: can't change the value of cit

const_iterator 对象可以用于 const vector 或非 const vector,因为不能改写元素值。const 迭代器这种类型几乎没什么用处:一旦它被初始化后,只能用它来改写其指向的元素,但不能使它指向任何其他元素。

  const vector<int> nines(10, 9);  // cannot change elements in nines

  // error: cit2 could change the element it refers to and nines is const

  const vector<int>::iterator cit2 = nines.begin();

  // ok: it can't change an element value, so it can be used with a const vector<int>

  vector<int>::const_iterator it = nines.begin();

  *it = 10; // error: *it is const

  ++it;     // ok: it isn't const so we can change its value

   // an iterator that cannot write elements

   vector<int>::const_iterator

   // an iterator whose value cannot change

   const vector<int>::iterator

迭代器的算术操作

除了一次移动迭代器的一个元素的增量操作符外,vector 迭代器(其他标准库容器迭代器很少)也支持其他的算术操作。这些操作称为迭代器算术操作(iterator arithmetic),包括:

iter + n

iter - n

可以对迭代器对象加上或减去一个整形值。这样做将产生一个新的迭代器,其位置在 iter 所指元素之前(加)或之后(减) n 个元素的位置。加或减之后的结果必须指向 iter 所指 vector 中的某个元素,或者是 vector 末端的后一个元素。加上或减去的值的类型应该是 vector size_type difference_type 类型(参考下面的解释)。

iter1 - iter2

该表达式用来计算两个迭代器对象的距离,该距离是名为 difference_type signed 类型 size_type 的值,这里的 difference_type signed 类型,因为减法运算可能产生负数的结果。该类型可以保证足够大以存储任何两个迭代器对象间的距离。iter1 iter2 两者必须都指向同一 vector 中的元素,或者指向 vector 末端之后的下一个元素。

可以用迭代器算术操作来移动迭代器直接指向某个元素,例如,下面语句直接定位于 vector 中间元素:

 vector<int>::iterator mid = vi.begin() + vi.size() / 2;

上述代码用来初始化 mid 使其指向 vi 中最靠近正中间的元素。这种直接计算迭代器的方法,与用迭代器逐个元素自增操作到达中间元素的方法是等价的,但前者的效率要高得多。

任何改变 vector 长度的操作都会使已存在的迭代器失效。例如,在调用 push_back 之后,就不能再信赖指向 vector 的迭代器的值了。

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息,谨防诈骗。如发现有害或侵权内容,请点击一键举报。

    来自: Fredanf > 《STL》

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多
    喜欢该文的人也喜欢 更多

    ×
    ×

    ¥.00

    微信或支付宝扫码支付:

    开通即同意《个图VIP服务协议》

    全部>>