Vector容器 和 iteration 迭代器

关键概念：vector对象动态增长                                                       

vector对象（以及其他标准库容器对象）的重要属性就在于可以在运行时高效地添加元素。因为vector增长的效率高，在元素值已知的情况下，最好是动态地添加元素。这种增长方式不同于C语言中的内置数据类型，也不同于大多数其他编程语言的数据类型。特别地，如果读者习惯了C或Java的风格，由于vector元素连续存储，可能希望最好是预先分配合适的空间。但事实上，为了达到连续性，C++的做法恰好相反。

关键概念：安全的泛型编程                                                       

习惯于C或Java编程的C++程序员可能会觉得难以理解，for循环的判断条件用!=而不是用<来测试vector下标值是否越界。C程序员难以理解的还有，上例中没有在for循环之前就调用size成员函数并保存其返回的值，而是在for语句头中调用size成员函数。C++程序员习惯于优先选用!=而不是<来编写循环判断条件。
调用size成员函数而不保存它返回的值，在这个例子中同样不是必需的，但这反映了一个良好的编程习惯。在C++中，有些数据结构（如vector）可以动态增长。上例中循环仅需要读取元素，而不需要增加新的元素。但是，循环可以容易地增加新元素，如果确实增加了新元素的话，那么测试已保存的size值作为循环的结束条件就会有问题，因为没有将新加入的元素计算在内。所以我们倾向于在每次循环中测试size的当前值，而不是在进入循环时，存储size值的副本。

我们知道，C++中有些函数可以声明为内联（inline）函数。编译器遇到内联函数时就会直接扩展相应代码，而不是进行实际的函数调用。像size这样的小库函数几乎都定义为内联函数，所以每次循环过程中调用它的运行时代价是比较小的。

警告：仅能对确知已存在的元素进行下标操作                                           

对于下标操作符([]操作符)的使用有一点非常重要，就是仅能提取确实已存在的元素，例如：

vector<int> ivec;      // empty vector

cout << ivec[0];        // Error: ivec has no elements!

vector<int> ivec2(10); // vector with 10 elements

cout << ivec[10];      // Error: ivec has elements 0...9

试图获取不存在的元素必然产生运行时错误。和大多数同类错误一样，不能确保执行过程可以捕捉到这类错误，运行程序的结果是不确定的。由于取不存在的元素的结果是未定义的，因而不同的实现会导致不同的结果，但程序运行时几乎肯定会以某种有趣的方式失败。

本警告适用于任何使用下标操作的时候，如string类型的下标操作，以及将要简要介绍的内置数组的下标操作。

不幸的是，试图对不存在的元素进行下标操作是程序设计过程中经常会犯的严重错误。所谓的“缓冲区溢出”错误就是对不存在的元素进行下标操作的结果。这样的缺陷往往导致PC机和其他应用中最常见的安全问题。

                        vector迭代器

除了使用下标来访问vector对象的元素外，标准库还提供了另一种检测元素的方法：使用迭代器（iterator）。迭代器是一种允许程序员检查容器内元素，并实现元素遍历的数据类型。

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

容器的iterator类型

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

vector<int>::iterator iter;

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

begin和end操作

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

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

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

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

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

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

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

迭代器类型可使用解引用操作符（*操作符）来访问迭代器所指向r 元素：

*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就自增1。for循环体将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类型解引用时，得到对某个元素的非const引用。而如果我们对const_iterator类型解引用时，则可以得到一个指向const对象的引用，如同任何常量一样，该对象不能进行重写。

例如，如果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 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），包括：

l iter + n

  iter - n

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

l iter1 - iter2                                                      

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

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

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

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

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