C++ STL之vector - 码农教程

介绍

vector(向量)：一个能够存放任意类型的动态数组。它是一个类模板，可用于表示多种不同的数据类型。

头文件

#include<vector>

初始化

1     vector<int> v; //定义一个int类型的向量v
2     vector<int> v1(5); //定义一个有五个int类型元素的向量v1
3     vector<int> v2(5,1); //定义一个有五个int类型元素的向量v2,所有元素初始值为0
4     vector<int> v3(v2); //定义一个int类型的向量v3,使用另一个向量v2进行赋值初始化
5     vector<int> v4(v2.begin(),v2.end()); //使用迭代器方式复制向量2中所有元素进行初始化
6     
7     int nArray[] = {1,2,3};
8     int nLeng = sizeof(nArray)/sizeof(int);
9     vector<int> v5(nArray,nArray+nLeng);//通过复制数组来进行向量初始化

大小（Size）和容量(Capacity)

empty() 　　是否为空

size() 　　元素的个数

max_size()　可容纳的元素的最大个数

capacity() 重新分配空间前所能容纳元素最大个数

resize() 在该容器尾部添加或删除一些元素,重新设置size大小

reserve() 重新设置capacity大小

注意：

resize()既修改size,也可能修改capacity

如果新的元素个数小于或等于原始元素个数,capacity保持不变,反之capacity=size

reserve() 只修改capacity，不会修改size大小

当增加一个元素时,如果超出capacity，需要重新分配空间、拷贝元素、撤销旧空间.

因此在创建vector时通常使用reserve()设置足够大的预留空间，这样当增加新元素时，

就不必重新分配空间、拷贝元素、撤销旧空间,提高执行效率

 1     vector<int> vv(10);
 2     bool bEmpty = vv.empty(); //bEmpty=false
 3     int nSize = vv.size(); //nSize=10
 4     int nMax_Size = vv.max_size(); //nMaxSize=0x3fffffff
 5     int nCapacity = vv.capacity();//nCapacity=10
 6 
 7     vv.resize(5);  
 8     nSize = vv.size();//nSize=5
 9     nCapacity = vv.capacity();//nCapacity=10
10 
11     vv.resize(20);
12     nSize = vv.size();//nSize=20
13     nCapacity = vv.capacity();//nCapacity=20
14 
15     vv.reserve(50);
16     nSize = vv.size();//nSize=20
17     nCapacity = vv.capacity();//nCapacity=50

增加元素

push_back(const T& x) 在向量尾部插入一个元素x

insert(iterator it,const T& x) 迭代器it指向的元素之前插入一个元素x

insert(iterator it,int n,const T& x) 迭代器it指向的元素之前增加n个相同的元素x

insert(iterator it,const_iterator first,const_iterator last) it指向的元素之前插入另一个

相同类型向量的first到last之间的元素

1     vector<int> v;
2     v.push_back(5);  //v[0]=5
3     v.insert(v.begin(),99); //v[0]=99 v[1]=5
4     v.insert(v.begin(),2,11); //v[0]=11 v[1]=11 v[2]=99 v[3]=5
5     vector<int> vNew(3,77);
6     v.insert(v.begin(),vNew.begin(),vNew.end());//v    [7](77,77,77,11,11,99,5)

删除元素

clear()　　　　　　　　　　　　清空向量中所有元素

pop_back() 删除向量中最后一个元素

erase(iterator it) 删除向量中迭代器指向的元素

erase(iterator first,iterator last) 删除向量中firet到last之间的元素

注意：删除元素时vector所占的内存空间不会被释放,只增不减.只有当vector析构时才会自动回收.

1     vector<int> v(4);
2     v[0] = 1;
3     v[1] = 2;
4     v[2] = 3;
5     v[3] = 4;
6     v.pop_back(); //size=3 v[0]=1 v[1]=2 v[2]=3
7     v.erase(v.begin()); //size=2 v[0]=2 v[1]=3
8     v.erase(v.begin(),v.end()); //size=0
9     v.clear();    //size=0

遍历元素

迭代器方式遍历

 1     vector<int> v(10);
 2     int i = 0;
 3     //通过迭代器方式顺序写入1-10
 4     for (vector<int>::iterator it = v.begin(); it<v.end(); it++)
 5     {
 6         *it = ++i;
 7     }
 8     //通过迭代器方式顺序读出所有元素
 9     for(vector<int>::const_iterator it = v.begin(); it<v.end(); it++)
10     {
11         cout<<*it<<endl;
12     }
13 
14     system("pause");

数组下标方式遍历

 1     vector<int> v(10);
 2     int i = 0;
 3     //通过数组下标方式顺序写入1-10
 4     for (int j=0; j<v.size(); j++)
 5     {
 6         v[j] = ++i;
 7     }
 8     //通过数组下标方式顺序读出所有元素
 9     for (int j=0; j<v.size(); j++)
10     {
11         cout<<v[j]<<endl;
12     }
13     system("pause");

at方式遍历

 1     vector<int> v(10);
 2     int i = 0;
 3     //通过at方式顺序写入1-10
 4     for (int j=0; j<v.size(); j++)
 5     {
 6         v.at(j) = ++i;
 7     }
 8     //通过at方式顺序读出所有元素
 9     for (int j=0; j<v.size(); j++)
10     {
11         cout<<v.at(j)<<endl;
12     }
13     //当超出范围时，会抛出异常std::out_of_range
14     v.at(11);
15 
16     system("pause");

注意：

这几种方式中at()是最慢的，因为需要检测访问是否越界,如果越界抛弃异常

数组下标的方式是最快的,但是由于其它容器不支持使用下标访问,不太常用

最常用的还是使用iterator方式，STL每种容器都有一套对应的iterator,通用性比使用下标强

释放内存

使用swap()交换二个对象,使vector离开其自身的作用域，从而强制释放vector所占的内存空间

1     vector<int> v(10,1);
2     v.clear();
3     int nCapacity = v.capacity(); //nCapacity=10
4     vector<int>().swap(v);
5     nCapacity = v.capacity(); //nCapacity=0
6     system("pause");