vector是STL中的最常见的容器，它是一种顺序容器，支持随机访问。简单的说vector就是一个能存放任意类型的动态数组，只不过数组是静态的分配空间，一旦分配了空间大小就不能在改变了，但是vector是动态分配内存，它随着元素的不断插入，会按照自身的一套机制不断扩充自己的容量。
vector的扩充机制：按照容器现在容量的一倍进行增长。vector容器分配的是一块连续的内存空间，每次容器的增长，并不是在原油连续的内存空间后在进行简单的叠加，而是重新申请一块更大的新内存，并把现有容器内的元素逐个复制过去，然后销毁旧的内存。这时原有指向旧内存空间的迭代器已经失效，所以当操作容器时，迭代器要及时更新。
vector是一个类模板。使用类模板可以编写一个类型定义或函数定义，而用于多个不同的数据类型。所以vector不是一种数据类型，而是一个类模板，可以用来定义任意多种数据类型，vector类型的每一种都制定了其保存元素的类型。
当我们要使用vector的时候，我们必须在头文件中加入 #include<vector>
vector是属于std命名域的，需要通过命名限定，
using std::vector; vector<int> vInts;
或者连在一起，使用全名
std::vector<int> vInts;
也可以使用全局的命名域方式：
using namespace std;
vector的初始化
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> vec1; //创建一个空的vector
vector<int> vec2(vec1); //复制vec1
vector<int> vec3(10); //创建一个vector，含有n个数据，数据均以缺省构造产生
vector<int> vec4(10, 1);//创建一个含有10个1的vector
}
vector的操作
vec.assign(beg,end);
vec.assign(n,elem);
// 将[beg; end)区间中的数据赋值给c。将n个elem的拷贝赋值给c。
vec.at(idx) // 传回索引idx所指的数据，如果idx越界，抛出out_of_range。
vec.back() // 传回最后一个数据，不检查这个数据是否存在。
vec.begin() // 传回迭代器中的第一个数据地址。
vec.capacity() // 返回容器当前已分配的容量。
vec.clear() // 移除容器中所有数据。
vec.empty() // 判断容器是否为空。
vec.end() // 指向迭代器中末端元素的下一个，指向一个不存在元素。
vec.erase(pos) // 删除pos位置的数据，传回下一个数据的位置。
vec.erase(beg,end) //删除[beg,end)区间的数据，传回下一个数据的位置。
vec.front() // 传回第一个数据。
get_allocator // 使用构造函数返回一个拷贝。
vec.insert(pos,elem) // 在pos位置插入一个elem拷贝，传回新数据位置。
vec.insert(pos,n,elem) // 在pos位置插入n个elem数据。无返回值。
vec.insert(pos,beg,end) // 在pos位置插入在[beg,end)区间的数据。无返回值。
vec.max_size() // 返回容器中最大数据的数量。
vec.pop_back() // 删除最后一个数据。
vec.push_back(elem) // 在尾部加入一个数据。
vec.rbegin() // 传回一个逆向队列的第一个数据。
vec.rend() // 传回一个逆向队列的最后一个数据的下一个位置。
vec.resize(num) // 重新指定队列的长度。
vec.reserve() // 保留适当的容量。
vec.size() // 返回容器中实际数据的个数。
vec1.swap(vec2)
swap(vec1,vec2) // 将c1和c2元素互换。同上操作。
下面是部分成员函数的操作
#include <iostream>
#include <vector> //必须包含头文件
using namespace std;
int main()
{
//几种vector声明
vector<int>v1; //定义空的vector
vector<int>v2(10); //产生大小为10的vector
vector<int>v3(10,-1); //产生大小为10，并且每个元素都是-1的vector
vector<int>v4(v3); //用一个vector产生一个vecotr
int arr[5]={1,2,3,4,5};
vector<int>v5(arr,&arr[5]); //以区间[beg;end)做为初值的vector
cout<<"当前元素数量"<<v5.size()<<endl;
cout<<"v1大小是否为0:"<< (v1.empty()?"空":"不空")<<endl;
cout<<"v2大小是否为0:"<< (v2.empty()?"空":"不空")<<endl;
cout<<"v1可容纳的元素最大数量:"<<v1.max_size()<<endl;
cout<<"v2可容纳的元素最大数量:"<<v2.max_size()<<endl;
cout<<"v2重新分配前所能容纳的元素最大数:"<<v2.capacity()<<endl;
v2.reserve(20); //给v2重新分配20个空间
cout<<"v2.reserve(20)后重新分配前所能容纳的元素最大数:"<<v2.capacity()<<endl;
cout<<"v3 v4是否相等:"<<(v3==v4 ? "相等":"不等")<<endl;
v1.push_back(11);//在尾部添加一个元素1
v1.push_back(22);
v1.push_back(33);
//迭代器是随机存取迭代器，对vector来说就是指针，迭代器持续有效
//除非在一个较小索引位置插入删除元素或者内存重新分配
vector<int>::iterator ita; //声明一个迭代器
int i=0;
for(ita=v1.begin(), i=0;ita != v1.end();i++,ita++)//v1.begin()指向v1的第一个元素，v1.end()指向最后元素的下一位置
{
cout<<"v1中的"<<i<<"值:"<<v1[i]<<endl;
}
v1.pop_back();//在尾部删除一个元素
for(ita=v1.begin(),i=0;ita != v1.end();i++,ita++)
{
cout<<"v1中的"<<i<<"值:"<<v1[i]<<endl;
}
//跟v1.begin()和v1.end()对应的有v1.rbegin()和v1.rend(),
//v1.begin()指向逆向的第一个元素，v1.end()指向逆向最后元素的下一位置，使用 vector<int>::reverse_iterator ita;
v2=v1; //将v1的元素全部拷到v2
for(ita=v2.begin(),i=0;ita != v2.end();i++,ita++)
{
cout<<"v2中的"<<i<<"值:"<<v2[i]<<endl;
}
//v2.clear();
v2.assign(3,44);
for(ita=v2.begin(),i=0;ita != v2.end();i++,ita++)
{
cout<<"v2中的"<<i<<"值:"<<v2[i]<<endl;
}
v2.assign(arr,&arr[5]);
for(ita=v2.begin(),i=0;ita != v2.end();i++,ita++)
{
cout<<"v2中的"<<i<<"值:"<<v2[i]<<endl;
}
v1.swap(v2);
//swap(v1,v2);
cout<<"v1第2个元素"<<v1.at(1)<<endl; //越界抛出异常
//cout<<"v1第6个元素"<<v1[5]<<endl; //越界，不检查
cout<<"v1首个元素"<<v1.front()<<endl;
cout<<"v1最后元素"<<v1.back()<<endl;
vector<int>::iterator pos=v1.begin();
v1.insert(pos,11);
//v1.insert(pos,4,55); //如果直接用就是错的，因为迭代器失效了
//v1.insert(pos,arr,&arr[5]);
for(ita=v1.begin(),i=0;ita != v1.end();i++,ita++)
{
cout<<"v1中的"<<i<<"值:"<<v1[i]<<endl;
}
cout<<endl;
pos=v1.begin(); //因为直接用迭代器失效，所以重新声明下
v1.erase(++pos); //删除制定位置
for(ita=v1.begin(),i=0;ita != v1.end();i++,ita++)
{
cout<<"v1中的"<<i<<"值:"<<v1[i]<<endl;
}
cout<<endl;
pos=v1.begin();
v1.erase(pos,pos+3);
for(ita=v1.begin(),i=0;ita != v1.end();i++,ita++)
{
cout<<"v1中的"<<i<<"值:"<<v1[i]<<endl;
}
cout<<endl;
//v1.resize(5); //将元素数量改成5，如果v1变大，则多的按默认走
v1.resize(5,9); //将元素数量改成5，如果v1变大，则多的赋值成9
for(ita=v1.begin(),i=0;ita != v1.end();i++,ita++)
{
cout<<"v1中的"<<i<<"值:"<<v1[i]<<endl;
}
cout<<endl;
v1.clear(); //清空
return 0;
}
以下内容来源于他人
内存管理与效率
1》使用reserve()函数提前设定容量大小，避免多次容量扩充操作导致效率低下。
关于STL容器，最令人称赞的特性之一就是是只要不超过它们的最大大小，它们就可以自动增长到足以容纳你放进去的数据。（要知道这个最大值，只要调用名叫max_size的成员函数。）对于vector和string，如果需要更多空间，就以类似realloc的思想来增长大小。vector容器支持随机访问，因此为了提高效率，它内部使用动态数组的方式实现的。在通过 reserve() 来申请特定大小的时候总是按指数边界来增大其内部缓冲区。当进行insert或push_back等增加元素的操作时，如果此时动态数组的内存不够用，就要动态的重新分配当前大小的1.5~2倍的新内存区，再把原数组的内容复制过去。所以，在一般情况下，其访问速度同一般数组，只有在重新分配发生时，其性能才会下降。正如上面的代码告诉你的那样。而进行pop_back操作时，capacity并不会因为vector容器里的元素减少而有所下降，还会维持操作之前的大小。对于vector容器来说，如果有大量的数据需要进行push_back，应当使用reserve()函数提前设定其容量大小，否则会出现许多次容量扩充操作，导致效率低下。
reserve成员函数允许你最小化必须进行的重新分配的次数，因而可以避免真分配的开销和迭代器/指针/引用失效。但在我解释reserve为什么可以那么做之前，让我简要介绍有时候令人困惑的四个相关成员函数。在标准容器中，只有vector和string提供了所有这些函数。
(1) size()告诉你容器中有多少元素。它没有告诉你容器为它容纳的元素分配了多少内存。
(2) capacity()告诉你容器在它已经分配的内存中可以容纳多少元素。那是容器在那块内存中总共可以容纳多少元素，而不是还可以容纳多少元素。如果你想知道一个vector或string中有多少没有被占用的内存，你必须从capacity()中减去size()。如果size和capacity返回同样的值，容器中就没有剩余空间了，而下一次插入（通过insert或push_back等）会引发上面的重新分配步骤。
(3) resize(Container::size_type n)强制把容器改为容纳n个元素。调用resize之后，size将会返回n。如果n小于当前大小，容器尾部的元素会被销毁。如果n大于当前大小，新默认构造的元素会添加到容器尾部。如果n大于当前容量，在元素加入之前会发生重新分配。
(4) reserve(Container::size_type n)强制容器把它的容量改为至少n，提供的n不小于当前大小。这一般强迫进行一次重新分配，因为容量需要增加。（如果n小于当前容量，vector忽略它，这个调用什么都不做，string可能把它的容量减少为size()和n中大的数，但string的大小没有改变。在我的经验中，使用reserve来从一个string中修整多余容量一般不如使用“交换技巧”，那是条款17的主题。）
这个简介表示了只要有元素需要插入而且容器的容量不足时就会发生重新分配（包括它们维护的原始内存分配和回收，对象的拷贝和析构和迭代器、指针和引用的失效）。所以，避免重新分配的关键是使用reserve尽快把容器的容量设置为足够大，最好在容器被构造之后立刻进行。
例如，假定你想建立一个容纳1-1000值的vector<int>。没有使用reserve，你可以像这样来做：
vector<int> v;
for (int i = 1; i <= 1000; ++i) v.push_back(i);
在大多数STL实现中，这段代码在循环过程中将会导致2到10次重新分配。（10这个数没什么奇怪的。记住vector在重新分配发生时一般把容量翻倍，而1000约等于210。）
把代码改为使用reserve，我们得到这个：
vector<int> v;
v.reserve(1000);
for (int i = 1; i <= 1000; ++i) v.push_back(i);
这在循环中不会发生重新分配。
在大小和容量之间的关系让我们可以预言什么时候插入将引起vector或string执行重新分配，而且，可以预言什么时候插入会使指向容器中的迭代器、指针和引用失效。例如，给出这段代码，
string s;
...
if (s.size() < s.capacity()) {
s.push_back(‘x‘);
}
push_back的调用不会使指向这个string中的迭代器、指针或引用失效，因为string的容量保证大于它的大小。如果不是执行push_back，代码在string的任意位置进行一个insert，我们仍然可以保证在插入期间没有发生重新分配，但是，与伴随string插入时迭代器失效的一般规则一致，所有从插入位置到string结尾的迭代器/指针/引用将失效。
回到本条款的主旨，通常有两情况使用reserve来避免不必要的重新分配。第一个可用的情况是当你确切或者大约知道有多少元素将最后出现在容器中。那样的话，就像上面的vector代码，你只是提前reserve适当数量的空间。第二种情况是保留你可能需要的最大的空间，然后，一旦你添加完全部数据，修整掉任何多余的容量。
2》使用“交换技巧”来修整vector过剩空间/内存
有一种方法来把它从曾经最大的容量减少到它现在需要的容量。这样减少容量的方法常常被称为“收缩到合适（shrink to fit）”。该方法只需一条语句：vector<int>(ivec).swap(ivec);
表达式vector<int>(ivec)建立一个临时vector，它是ivec的一份拷贝：vector的拷贝构造函数做了这个工作。但是，vector的拷贝构造函数只分配拷贝的元素需要的内存，所以这个临时vector没有多余的容量。然后我们让临时vector和ivec交换数据，这时我们完成了，ivec只有临时变量的修整过的容量，而这个临时变量则持有了曾经在ivec中的没用到的过剩容量。在这里（这个语句结尾），临时vector被销毁，因此释放了以前ivec使用的内存，收缩到合适。
3》用swap方法强行释放STL Vector所占内存
template < class T> void ClearVector( vector<T>& v )
{
vector<T>vtTemp;
vtTemp.swap( v );
}
如
vector<int> v ;
nums.push_back(1);
nums.push_back(3);
nums.push_back(2);
nums.push_back(4);
vector<int>().swap(v);
/* 或者v.swap(vector<int>()); */
/*或者{ std::vector<int> tmp = v; v.swap(tmp); }; //加大括号{ }是让tmp退出{ }时自动析构*/