C++新经典10--vector以及其使用

vector

vector类型是一个标准库中的类型，代表一个容器、集合或者动态数组这样一种概念。既然是容器，那就可以把若干个对象放到里面。当然，这些对象的类型必须相同。简单来说，可以把一堆int型数字放到vector容器中去，复杂点说，可以把一堆相同类型的类对象放到vector容器中去。

所以，如果换个角度考虑，vector能把其他对象装进来，所以称为容器非常合适。容器这个概念经常被提及，读者要知道和理解这个概念。

要想使用这种类型，需要在.cpp源文件开头包含vector头文件：

另外，为了方便引用这种类型，也要书写：

定义一个vector类型对象。显然，一旦定义出来，这个对象就是容器了。例如想在里面保存int型数据（容器里面所要装的元素类型），看如下代码：

上面的代码定义了一个vector类型的对象，名字叫作vjihe，这个对象里面保存的就是int型数据。为什么是int型数据呢？读者可以看到，vector后面有一对“＜＞”，“＜＞”里面是int，表示这个vector类型的对象（容器）里面存放的是int型对象（int型数据/元素）。

这个＜int＞的写法读者可能第一次见到，会觉得是一种奇怪的写法，在后面章节中会讲到“类模板”的概念，其实vector就是一个类模板，这里的“＜＞”实际上是类模板的一个实例化过程。但是类模板的实例化过程眼下对于读者来讲，理解起来还比较生涩，后面学习模板的时候再详细阐述，所以这里笔者换一种说法来帮助读者理解类模板。

vector理解成一个残缺的类类型，这意味着使用时光有类名vector还不够，还需要额外给vector类模板提供其要在其中保存什么类型数据的信息，这个信息就是通过＜int＞来提供（模板名后跟一对“＜＞”，“＜＞”内放入类型信息），所以，在使用vector时，一定要在它后面跟一对“＜＞”并在其中跟一个该vector容器中要保存的数据（元素）类型的信息，这才算一个完整的类型（完整的类类型）。例如，vector不是一个完整类型，而vector＜int＞却是一个完整的类型。看看如下范例：

一般来讲，vector容器里面可以装很多种不同类型的数据作为其元素（容器中装的内容简称“元素”）。看看如下范例：

但是vector不能用来装引用。请记住，引用只是一个别名，不是一个对象。所以，下面的写法会报语法错误：

定义和初始化vector对象

（1）空vector。
定义如下：

vector<string> mystr;
//创建一个string类型的空vector对象（容器），
//现在mystr里不包含任何元素

后续就可以用相关的一些操作函数往这个空对象里增加数据了。

例如，可以往这个容器的末尾增加一些数据。这里可以使用vector的成员函数push_back往容器末尾增加数据。看看如下范例，注意看它的下标[0]，[1]，[2]，…不断增长，如图13.3所示。

mystr.push_back("abcd");
mystr.push_back("def");

（2）在vector对象元素类型相同的情况下，进行vector对象元素复制（新副本）。

vector<string> mystr2(mystr);	//把mystr元素复制给了mystr2
vector<string>mystr3 = mystr;	//把mystr元素复制给了mystr3

（3）在C++11中，还可以用初始化列表方法给初值，这个时候用“{}”括起来。

vector<string> def = {"aaa","bbb","ccc"};

当然“{}”里面为空也可以，那就相当于没有初始化，是一个空的vector了。

（4）创建指定数量的元素。请注意，有元素数量概念的初始化，用的都是“（）”。

如果不给元素初值，那么元素的初值要根据元素类型而定，例如元素类型为int，系统给的初值就是0，元素类型为string，系统给的初值就是""，但也存在有些类型，必须给初值，否则就会报错。
如下范例演示不给元素初值的情况：

vector<int> ijihe2(20);	//20个元素，下标[0]~[19]，每一个元素值都为0
vector<string> sjihe2(5);	//15个元素，下标[0]~[4]，每一个元素值都为""

（5）多种初始化。“（）”一般表示对象中元素数量这种概念，“{}”一般表示元素的内容这种概念，但又不是绝对。看看如下范例：

vector对象上的操作

其实，在使用vector时，最常见的情况是并不知道vector里会有多少个元素，使用时会根据需要动态地增加和减少。所以一般来讲，使用者是先创建一个空的vector对象，然后通过代码向这个vector里增加或减少元素。这里将要介绍一些vector类型提供的常用方法。vector上很多的操作和string很相似。
（1）判断是否为空empty（），返回布尔值。

   vector<int> ivec;
    if (ivec.empty())   //条件成立
    {   
        cout<<"ivec为空"<<endl;
    }

（2）push_back：一个非常常用的方法，用于向vector末尾增加一个元素。

    vector<int> ivec;  //先声明成空的vector对象
    ivec.push_back(1);
    ivec.push_back(2);
    for (int i=3;i<=100;i++)
    {
    ivec.push_back(i);
    }

在上面的范例中，注意观察，能够发现，值2在值1的后面（最后插入的元素在vector容器的最末尾）。调试结果如下图所示。

（3）size：返回元素个数。
（4）clear：移除所有元素，将容器清空。
（5）v[n]：返回v中的第n个字符（n是一个整型值），位置从0开始计算，位置值n也必须小于.size（），如果下标引用超过这个范围，或者用下标访问一个空的vector，都会产生不可预测的结果（因为编译器可能发现不了这种错误）

（6）赋值运算符（=）。

    vector<int> ivec;
    //先声明成空的vector对象
    ivec.push_back(1);
    ivec.push_back(2);
    for (int i=3;i<=100;i++)
    {
        ivec.push_back(i);
    }
    vector<int> ivec2;
    ivec2.push_back(111);
    ivec2=ivec;//也得到了100个元素，用ivec中的内容取代了ivec2中原有内容，上行这个111就
               //被冲掉了
    ivec2={12,13,14,15};
    //用{}中的值取代了ivec2原有值
    cout<<ivec2.size()<<endl;  //4

（7）相等和不等（==和!=）。
两个vector对象相等：元素数量相同，对应位置的元素值也都相同。否则就是不相等。

（8）范围for的应用：和讲解string时对范围for的应用类似

    vector<int> vecvalue{1,2,3,4,5 };
    for(auto& vecitem:vecvalue)  //为了修改vecvalue内部值，这里是引用，引用会绑定到元素上，达
                                //到通过引用改变元素值的目的
    
        vecitem *= 2;       //扩大一倍
        
    for (auto vecitem : vecvalue)
    cout << vecitem << endl;

针对范围for语句，这里希望引申一步进行讲解。如果在范围for中，增加改变vector容量的代码，则输出就会变得混乱：

    vector<int> vecvalue{1,2,3,4,5 };
    for (auto vecitem : vecvalue)
    {
        vecvalue.push_back(888);
        cout << vecitem << endl;

    }

范围for，在这里用来遍历vector容器中的元素。这里的vecitem是定义的一个变量，后面的vecvalue是一个序列（容器），for语句中使用auto来确保序列中的每个元素都能够转换成变量vecitem对应的类型，所以一般在范围for语句中习惯使用auto（编译器来指定合适的vecitem类型）。

那为什么上述代码会产生混乱的输出呢？

因为每次执行for循环，都会重新定义vecitem，并且把它的值初始化成vecvalue序列中的下一个值。在刚刚进入这个for循环时，在系统内部会记录序列结束的位置值，但一旦在这个范围for里面改动这个序列的容量（如增加/删除元素），那么这个序列结束的位置值就肯定会发生改变，这个改变会导致for语句的混乱，其输出的值也就乱了。

所以，请记住一个结论，在for语句中，不要改变vector的容量，增加、删除元素都不可以。请读者千万千万不要写出这种错误代码，否则隐患无穷，切记切记！

迭代器精彩演绎、失效分析及弥补、实战

迭代器简介

迭代器是一个经常听到和用到的概念。上一节学习了vector，笔者说过，这是一个容器，里面可以容纳很多对象。那迭代器是什么呢？迭代器是一种遍历容器内元素的数据类型。这种数据类型感觉有点像指针，读者就理解为迭代器是用来指向容器中的某个元素的。

string可以通过“[]”（下标）访问string字符串中的字符，vector可以通过“[]”访问vector中的元素。但实际上，在C++中，很少通过下标来访问它们，一般都是采用迭代器来访问。

除了vector容器外，C++标准库中还有几个其他种类的容器。这些容器都可以使用迭代器来遍历其中的元素内容。string其实是字符串，不属于容器，但string也支持用迭代器遍历。

通过迭代器，可以读取容器中的元素值、修改容器中某个迭代器所代表（所指向）的元素值。此外，迭代器可以像指针一样——通过++、–等运算符从容器中的一个元素移动到另一个元素。

许多容器如上述的vector，在C++标准库中，还有其他容器如list、map等都属于比较常用的容器，C++标准库为每个这些容器都定义了对应的一种迭代器类型，有很多容器不支持“[]”操作，但容器都支持迭代器操作。写C++程序时，笔者也强烈建议读者不要用下标访问容器中的元素，而是用迭代器来访问容器中的元素。

容器的迭代器类型

刚刚讲过，C++标准库为每种容器都定义了对应的迭代器类型。这里就以容器vector为例，演示一下：

    vector<int> iv = {100,200,300};     //定义一个容器
    vector<int >:: iterator iter;       //定义迭代器，也必须是以vector<int>开头

上面的语句是什么意思呢？后面这条语句定义了一个名为iter的变量（迭代器），这个变量的类型是vector＜int＞::iterator类型，请注意这种写法“::iterator”。iterator是什么？它是每个容器（如vector）里面都定义了的一个成员（类型名），这个名字是固定的，请牢记。
在理解的时候，就把整个vector＜int＞::iterator理解成一种类型，这种类型就专门应用于迭代器，当用这个类型定义一个变量的时候，这个变量就是一个迭代器。

迭代器begin/end、反向迭代器rbegin/rend操作

1.迭代器

每一种容器，如vector，都定义了一个叫begin的成员函数和一个叫end的成员函数。这两个成员函数正好用来返回迭代器类型。看看如下范例。
（1）begin返回一个迭代器类型（就理解成返回一个迭代器）。

（2）end返回一个迭代器类型（就理解成返回一个迭代器）。

对上面的代码进行跟踪调试，观察begin和end结果可以看到，end（）指向了一个乱数字，如图13.5所示。

    vector<int> iv = {100,200,300};     //定义一个容器
    vector<int >::iterator iter;       //定义迭代器，也必须是以vector<int>开头
    iter = iv.begin();
    iter = iv.end();

（3）如果容器为空，则begin返回的迭代器和end返回的迭代器相同。看看如下范例：

    vector<int> iv2;
    vector<int>::iterator iterbegin = iv2.begin();
    vector<int>::iterator iterend = iv2.end();
    if (iterbegin == iterend)   //条件成立
    {
        cout << "容器为空" << endl;
    }

所以，end返回的迭代器并不指向容器vector中的任何元素，它起到实际上是一个标志（岗哨）作用，如果迭代器从容器的begin位置开始不断往后游走，也就是不断遍历容器中的元素，那么如果有一个时刻，iter走到了end位置，那就表示已经遍历完了容器中的所有元素。
（4）写一段代码，传统的通过迭代器访问容器中元素的方法如下：

    vector<int>iv={100,200,300};    //定义一个容器
    //经典传统用法，这里用++、！=等运算符来对迭代器进行操作
    for (vector<int>::iterator iter = iv.begin();iter != iv.end();iter++)
    {
        cout << *iter << endl;
    }

运行起来看结果：100、200、300。

2.反向迭代器

如果想从后面往前遍历一个容器，那么，用反向迭代器就比较方便。反向迭代器使用的是rbegin成员函数和rend成员函数。
（1）rbegin返回一个反向迭代器类型，指向容器的最后一个元素。
（2）rend返回一个反向迭代器类型，指向容器的第一个元素的前面位置。
rbegin和rend成员函数指向的容器位置示意图如图13.7所示。

看看如下范例：

    vector<int>iv={100,200,300};
    for (vector<int>::reverse_iterator riter = iv.rbegin(); riter != iv.rend(); riter++)
    {
        cout<<*riter<<endl;
    }
    

运行起来看结果：300、200、100。

迭代器运算符

（1）iter：返回迭代器iter所指向元素的引用。必须要保证该迭代器指向的是有效的容器元素，不能指向end，因为end是末端元素后面的位置，也就是说，end已经指向了一个不存在元素。前面的cout≪iter≪endl；就是使用*iter的演示范例，这里不做进一步演示了。
（2）++iter：和iter++是同样的功能——让迭代器指向容器中的下一个元素。但是已经指向end的迭代器，不能再++，否则运行时报错。
（3）–iter：和iter–是同样的功能——让迭代器指向容器中的前一个元素。了解++自然也就能了解–。看看如下范例：

（4）iter1==iter2或iter1!=iter2：判断两个迭代器是否相等。如果两个迭代器指向的是同一个元素，就相等，否则就不相等。
（5）结构成员的引用。看看如下范例：

请注意，一定要确保迭代器指向有效的容器中的元素，否则范例中的这些行为可能会导致意想不到的结果。还有很多其他运算符，例如迭代器之间可以相减表示两个迭代器之间的距离，迭代器加一个数字表示跳过多少个元素，不过这些都不常用，不准备逐一介绍，意义也不大。读者如果以后遇到，有了现在所学的基础，再简单学习一下即可。

const_iterator迭代器

前面学习了iterator这种迭代器类型，实际上每种容器还有另外一种迭代器类型，叫作const_iterator，从名字上能感觉到其含义：有const在，一般都表示常量，也就是说值不能改变的意思。这里的值不能改变表示该迭代器指向的元素的值不能改变，并不表示该迭代器本身不能改变，该迭代器本身是能改变的，也就是说，该迭代器是可以不断地指向容器中的下一个元素的。

所以该迭代器只能从容器中读元素，不能通过该迭代器修改容器中的元素。所以说，从感觉上来讲，const_iterator更像一个常量指针，而iterator迭代器是能读能写的。看看如下范例：

什么时候用const_iterator呢？如果这个容器对象是一个常量，那么就必须使用const_iterator，否则报错：

这里再额外看一看cbegin和cend成员函数。这是C++11引入的两个新函数，与begin、end非常类似。但是，不管容器是否是常量容器，cbegin、cend返回的都是常量迭代器const_iterator。看看如下范例：

迭代器失效

上一节在讲vector容器时谈过范围for循环语句——在遍历容器的时候，如果在for循环中，通过push_back等手段往容器中增加元素，范围for循环输出的容器中元素就会混乱。其实，范围for语句等价于常规的用迭代器对容器进行操作。看如下代码：

    vector<int> vecvalue{1,2,3,4,5 };
    for (auto vecitem:vecvalue)
    {
        cout << vecitem <<endl;
    }

等价于迭代器这种操作方式：

但如果一旦在for循环中增删容器中的元素，就会导致迭代器失效，整个结果就混乱了。
其实，任何一种能够改变vector对象容量的操作，如push_back，都会使当前的vector对象迭代器失效，所以请读者谨记：在操作迭代器的过程中（使用了迭代器的这种循环体），千万不要改变vector对象的容量，也就是不要增加或者删除vector容器中的元素。看如下代码：

对于向容器中添加元素和从容器中删除元素操作要小心，因为这些操作可能都会使指向容器元素的迭代器（也包括指针、引用等）失效。这种失效就表示它不能再代表任何容器中的元素，一旦使用这种失效的迭代器，就表示程序的书写犯了严重错误，很多情况下都会导致程序崩溃，就好比使用了没有被初始化的指针一样。

不同的容器实现机理不同（例如有的容器内部数据是连续存储的，插入元素时一旦原有内存不够用，则可能就会导致容器中原有数据全部迁移到一个新内存去，如vector等容器），不同的插入操作、不同的插入位置，会导致迭代器、指针、引用部分或者全部失效，甚至在循环体中的诸如vecvalue.end（）代码都会因为插入数据操作导致失效。

另一种情况是删除操作。如果从容器中删除一个元素，那么，当前指向这个被删除元素的迭代器、指针、引用肯定是立即失效，绝不能再引用它们。

此外，不同的容器，针对删除操作，不同的删除位置，也会导致迭代器、指针、引用部分或者全部失效，甚至在循环体中的诸如vecvalue.end（）代码都会因为删除数据操作导致失效。

解决方法就是：如果在一个使用了迭代器的循环中插入元素到容器，那只插入一个元素后就应该立刻跳出循环体，不能再继续用这些迭代器操作容器。看看如下范例：

下面将进行一些灾难程序演示。
（1）灾难程序演示1
下面代码目前一切没有问题：

接着，往循环中增加代码，注意while循环体中代码的变化：

有些人可能有更多需求，例如就是想不断地插入多条数据，并且还希望迭代器不失效，那就得查资料研究，如研究针对vector容器，如何写insert这段代码，才能让迭代器不失效，让程序安全地运行。看如下代码，是一种满足连续插入多条数据的解决方案：