C++ vector的初始化、添加、遍历、插入、删除、查找、排序、释放操作

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);

}