C++的vector本质上是一个动态数组，数据量不大的情况下，非常方便存储和访问操作，当然，不好的情况是数据量大的情况下，查找效率低，删除操作还会导致大量的数组移动操作。
虽然这样，vector还是一个很有用的东西，可以满足很多开发需求。
1. vector的初始化
Vector是向量模板，C++ STL之一。前面说过vector是一个动态生长的数组，一开始vector为空时，会给一个初始化的容量（就是允许的添加个数），并申请好内存了，当往vector里面添加的元素超过现在的容量（capacity）时，就会重新更大申请内存，并把之前的所有元素，拷贝到新内存中。
因此，我们最好用到vector时，最好给他一个初始化大小，避免更多的内存申请动作和移动操作。
初始化vector元素的个数例子:
typedef std::vector < Type > VectorT;
VectorT a(10);
Type是类型，可以是结构体、整型、指针，类对象，指针函数等。
VectorT a(10);定义了一个初始化大小10，类型为Type的vector向量。定义后a有10个初始值为0的元素，因此要调用a.clear()把这些元素清空，清空后STL并不会销毁10个元素的内存。
其实初始化方法：
（1）初始化一个空的vector：
VectorT a;
（2）初始化n个值为value的vector
VectorT a( n , value);
2.添加元素（添加到末尾）
调用push_back()函数
void push_back (const value_type& val);
a是vector向量
a.push_back( val);
如果vector的容器已满，在末尾添加元素时会alloc申请更大的内存，并拷贝之前的元素到新内存，再把元素添加到vector容器末尾。
3.查找
调用find方法（需要include<algorithm>）
template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val)
如查找元素为value，找到则返回迭代器的位置，否则迭代器将指向end()
std::vector < Type >:: iterator iVector;
iVector = std::find(a.begin(), a.end() , value);
If( iVector != a.end())
{
找到了
}
Else
{
没找到。
}
4.遍历
利用迭代器，一开始迭代器iVector指向begin，只要不等于end,就继续遍历下去
typedef std::vector < Type > VectorT;
VectorT a;
VectorT::iterator iVector = a.begin();
while(iVector != a.end())
{
std::cout<<" dump "<< (*iVector)<<std::endl;
++iVector;
}
5.删除末尾元素或者删除全部元素。
（1）删除一个末尾元素
a.pop_back();
//删除操作避免大量移动的方法，如果元素有申请堆栈的内存，需要换另外一种方法删除，因为需要先获取元素，释放元素指向的申请内存后，才能做删除操作，不然会造成内存泄漏。
（2）删除全部元素
while(pVector->size() != 0)
{
//pop_back方法无返回值
pVector->pop_back();
//删除操作避免大量移动的方法，如果元素有申请堆栈的内存，不可用此方法
}
（3）调用clear函数删除全部元素
a.clear()
（3）另外一种删除全部元素的方法
这种方法针对元素有另外申请内存的情况下比较有用，比如元素是一个结构体或者对象，有成员p申请了堆内存，删除元素前要释放内存。
VectorT::iterator iVector = a.begin();
while(iVector != a.end())
{
delete (*iVector)->p;
iVector = a.erase(iVector);
//执行erase后，iVector将指向删除的元素的下一个元素
}
6.删除一个不一定是末尾的元素
先执行find查找value的值，在vector容器里面就删除
VectorType::iterator iVector = std::find(a.begin(), a.end(), value);
if(iVector != a.end())
{
a.erase(iVector); //参数只能是迭代器
//std::cout<<" erase success "<< m<<std::endl;
}
7.插入一个元素
single element (1)
iterator insert (iterator position, const value_type& val);
fill (2)
void insert (iterator position, size_type n, const value_type& val);
range (3)
template <class InputIterator>_x000D_ void insert (iterator position, InputIterator first, InputIterator last);
Vector向量的元素插入有三种方法。
（1） insert (iterator position, const value_type& val)传入的参数是迭代器的位置和需要插入的元素val。
Position可以是a.begin()，也可以是a.end()，或者这两者中间的一个迭代器位置
（2）void insert (iterator position, size_type n, const value_type& val);
在position位置开始，插入n个值为val的元素
（3）void insert (iterator position, InputIterator first, InputIterator last);
在position位置插入first（比如数组首地址）到last（比如数组首地址+n）之间的元素。
最常用的是insert (iterator position, const value_type& val);
8.capacity()和size()
容器对象调用size()可以知道当前容器里面有多少个元素，对vector向量对象来说，就是当前存放的元素的个数。
容器对象调用capacity()函数，可以知道容器的大小，也就是当前容器对象可用容纳的元素个数。Capacity随着向量的元素的增加而增加，当size() ==capacity()时，容器会自动重新alloc内存，增加一倍的内存。
9.排序
default (1)
template <class RandomAccessIterator> void sort (RandomAccessIterator first, RandomAccessIterator last);
custom (2)
template <class RandomAccessIterator, class Compare> void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
std::sort( a.begin() , a.end() );
也可以是
std::sort( a.begin() , a.begin + 4 );
反正就是传入排序的位置范围。
默认是升序
另外可以实现自己的排序函数Compare comp
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
10.释放vector容器自身的内存
通过调用erase函数删除元素或者调用clear函数，虽然清楚了vector容器里面的元素，但是并没有释放调容器本身的内存，就好像一个装满了腰果的瓶子，把里面的腰果倒掉了，瓶子并没有被销毁。
释放方法：
比如定义有对象a,有10个元素在里面。
typedef std::vector < Type > VectorT;
VectorT a(10);
std::vector < Type >().swap( a );
代码实例：
#include <iostream>
#include <vector>
#include <algorithm>
typedef unsigned long U32;
typedef std::vector < U32 > VectorType;
int add(VectorType *pVector ,U32 m)
{
if(NULL == pVector)
{
return -1;
}
pVector->push_back(m); //添加元素到末尾//无返回值
return 0;
}
int remove(VectorType *pVector ,U32 m)
{
if(NULL == pVector)
{
return -1;
}
VectorType::iterator iVector = std::find(pVector->begin(), pVector->end(), m);
if(iVector != pVector->end())
{
pVector->erase(iVector); //参数只能是迭代器
std::cout<<" erase success "<< m<<std::endl;
}
else
{
std::cout<<" not find in pVector"<< m<<std::endl;
}
return 0;
}
int remove_last_one(VectorType *pVector )
{
if(NULL == pVector)
{
std::cout<<"pVector is NULL,(remove_last_one)"<<std::endl;
return -1;
}
if(pVector->empty())
{
std::cout<<"pVector is empty , remove_last_one"<<std::endl;
return -1;
}
pVector->pop_back(); //删除最后一个元素
return 0;
}
int remove_all(VectorType *pVector )
{
if(NULL == pVector)
{
std::cout<<"pVector is NULL,(remove_all)"<<std::endl;
return -1;
}
#if 0
VectorType::iterator iVector = pVector->begin();//;std::find(pVector->begin(), pVector->end(), m);
while(iVector != pVector->end())
{
std::cout<<" remove_all a "<< (*iVector)<<std::endl;
iVector = pVector->erase(iVector);
std::cout<<" remove_all b "<< (*iVector)<<std::endl;
}
#endif //这种做法导致大量的移动操作，但好处是如果元素是指针，我们可以先把内存
//释放了再删除
//erase的返回值是指向删除元素的下一个元素的迭代器指针
#if 1
while(pVector->size() != 0)
{
//pop_back方法无返回值
pVector->pop_back();//删除操作避免大量移动的方法，如果元素有申请堆栈的内存，不可用此方法
}
#endif
#if 0
//以下方法不可行
VectorType::iterator iVector = pVector->end();//;std::find(pVector->begin(), pVector->end(), m);
while(iVector != pVector->begin())
{
std::cout<<" remove_all a "<< (*iVector)<<std::endl;
iVector = pVector->erase(iVector);
std::cout<<" remove_all b "<< (*iVector)<<std::endl;
}
#endif
return 0;
}
void dump(VectorType *pVector)
{
if(NULL == pVector)
{
std::cout<<"pVector is NULL"<<std::endl;
return ;
}
if(pVector->empty()) //判断是否为空
{
std::cout<<"pVector is empty"<<std::endl;
return ;
}
VectorType::iterator iVector = pVector->begin();
while(iVector != pVector->end())
{
std::cout<<" dump "<< (*iVector)<<std::endl;
++iVector;
}
return ;
}
int find(VectorType *pVector ,U32 m,int *pnFlag)
{
if(NULL == pVector || NULL == pnFlag)
{
return -1;
}
*pnFlag = 0;
VectorType::iterator iVector = std::find(pVector->begin(), pVector->end(), m);
if(iVector != pVector->end())
{
std::cout<<" find success "<< m<<std::endl;
*pnFlag = 1;
return 0;
}
else
{
std::cout<<" not find in pVector"<< m<<std::endl;
return -1;
}
}
int insert_one(VectorType *pVector ,U32 val, int iPlace)
{
int i = 0;
if(NULL == pVector || iPlace < 0)
{
std::cout<<"insert_one param error"<<std::endl;
return -1;
}
VectorType::iterator iVector = pVector->begin();
while(iVector != pVector->end())
{
//std::cout<<" dump "<< (*iVector)<<std::endl;
if(i == iPlace)
{
iVector = pVector->insert(iVector , val); //此时insert的返回值是迭代器，插入成功后iVector指向插入的位置
std::cout<<" insert_one after iVector point "<< (*iVector)<<std::endl;
return 0;
}
i++;
++iVector;
}
iVector = pVector->insert(pVector->end() , val);
return 0;
}
int print_size(VectorType *pVector)
{
if(NULL == pVector)
{
std::cout<<"pVector is NULL"<<std::endl;
return -1;
}
if(pVector->empty()) //判断是否为空
{
std::cout<<"pVector is empty (get_size)"<<std::endl;
}
std::cout<<"pVector capacity: "<< pVector->capacity() << " size:"<<pVector->size()<<std::endl;
return 0;
}
int main()
{
VectorType vArray(20);//初始化20个元素的容器
int nFlag =0;
vArray.clear();//把容器的里的元素全部清掉
//添加元素
add(&vArray,5);
add(&vArray,4);
add(&vArray,3);
add(&vArray,2);
add(&vArray,1);
add(&vArray,0);
//插入一个元素 值为6
U32 val = 6;
int place = 2;
insert_one(&vArray, val, place);
//打印capatity size
print_size(&vArray);
dump(&vArray);
//删除末尾元素
remove_last_one(&vArray);
print_size(&vArray);
U32 element = 1;
find(&vArray ,element,&nFlag);
remove(&vArray ,element);
find(&vArray ,element,&nFlag);
element = 8;
//移除元素element
remove(&vArray ,element);
//查找element
find(&vArray ,element,&nFlag);
//移除所有元素
remove_all(&vArray);
dump(&vArray);
print_size(&vArray);
std::vector < U32 >().swap(vArray);//销毁向量的做法
print_size(&vArray);
}