一、什么是vector？

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

二、容器特性

1.顺序序列

顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。

2.动态数组

支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算述进行该操作。操供了在序列末尾相对快速地添加/删除元素的操作。

3.能够感知内存分配器的（Allocator-aware）

容器使用一个内存分配器对象来动态地处理它的存储需求。

4.函数功能

1.push_back 在数组的最后添加一个数据

2.pop_back 去掉数组的最后一个数据

3.at 得到编号位置的数据

4.begin 得到数组头的指针

5.end 得到数组的最后一个单元+1的指针

6.front 得到数组头的引用

7.back 得到数组的最后一个单元的引用

8.max_size 得到vector最大可以是多大

9.capacity 当前vector分配的大小

10.size 当前使用数据的大小

11.resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值

12.reserve 改变当前vecotr所分配空间的大小

13.erase 删除指针指向的数据项

14.clear 清空当前的vector

15.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)

16.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)

17.empty 判断vector是否为空

18.swap 与另一个vector交换数 

以上参考：菜鸟教程

c++ STL中对于verctor 的数据压入过程应该采用的是深拷贝，同时每压入一个新的元素时都会将之前的拷贝的对象进行清理，然后压入新的数据，源码中的处理过程：

void reserve(size_type _Count)
		{	// determine new minimum length of allocated storage
		if (max_size() < _Count)
			_Xlen();	// result too long
		else if (capacity() < _Count)
			{	// not enough room, reallocate
			pointer _Ptr = this->_Alval.allocate(_Count);
 
			_TRY_BEGIN
			_Umove(this->_Myfirst, this->_Mylast, _Ptr);
			_CATCH_ALL
			this->_Alval.deallocate(_Ptr, _Count);
			_RERAISE;
			_CATCH_END
 
			size_type _Size = size();
			if (this->_Myfirst != 0)
				{	// destroy and deallocate old array
				_Destroy(this->_Myfirst, this->_Mylast);
				this->_Alval.deallocate(this->_Myfirst,
					this->_Myend - this->_Myfirst);
				}
 
			this->_Orphan_all();
			this->_Myend = _Ptr + _Count;
			this->_Mylast = _Ptr + _Size;
			this->_Myfirst = _Ptr;
			}
		}

关于vector 的内存释放问题，如果是存储的临时变量或者临时对象，释放时不需要进行单独对象的内存释放,调用clear()函数时，系统会自动进行内存清理。

测试代码：

#include <iostream>
#include <vector>
using namespace std;
 
 class Data
 {
 public:
	 Data(int i){ 
		 id = i;
	 return;
	 };
	 ~Data(){
	 cout<<"内存析构,ID:"<<id<<endl;
	 return;
	 }
	int id;
 };
 
						 
int main()
{
  	vector<Data> m_group;
	Data pdata(1) ;//= new Data();
	Data pdata1(2);// = new Data();
	Data pdata2(3);
	Data pdata3(4);
	m_group.push_back(pdata);
	m_group.push_back(pdata1);
	m_group.push_back(pdata2);
	m_group.push_back(pdata3);
 
	cout<<"Group Size:"<<m_group.size()<<endl;
	cout<<"Group capacity():"<<m_group.capacity()<<endl;
 
	/*for each(auto it in m_group)
		delete it;*/
	m_group.clear();
	vector<Data>().swap(m_group);
	cout<<"Group Size:"<<m_group.size()<<endl;
	cout<<"Group capacity():"<<m_group.capacity()<<endl;
 
	getchar();
	return 0;
 
}	  
 

运行结果：

下面说一说 关于new对象的存储释放问题

上代码：

#include <iostream>
#include <vector>
using namespace std;
 
 class Data
 {
 public:
	 Data(int i){ 
		 id = i;
	 return;
	 };
	 ~Data(){
	 cout<<"内存析构,ID:"<<id<<endl;
	 return;
	 }
	int id;
 };
 
						 
int main()
{
  	vector<Data*> m_group;
	Data* pdata = new Data(1);
	Data* pdata1 = new Data(2);
	m_group.push_back(pdata);
	m_group.push_back(pdata1);
 
 
	cout<<"Group Size:"<<m_group.size()<<endl;
	cout<<"Group capacity():"<<m_group.capacity()<<endl;
 
	/*for each(auto it in m_group)
		delete it;*/
	m_group.clear();
	vector<Data*>().swap(m_group);
	cout<<"Group Size:"<<m_group.size()<<endl;
	cout<<"Group capacity():"<<m_group.capacity()<<endl;
 
	getchar();
	return 0;
 
}	  

运行结果：

可以看到Data类的析构函数并没有被调用，此处会造成内存泄漏，需要手动释放其中内存

代码如下：

#include <iostream>
#include <vector>
using namespace std;
 
 class Data
 {
 public:
	 Data(int i){ 
		 id = i;
	 return;
	 };
	 ~Data(){
	 cout<<"内存析构,ID:"<<id<<endl;
	 return;
	 }
	int id;
 };
 
						 
int main()
{
  	vector<Data*> m_group;
	Data* pdata= new Data(1);
	Data* pdata1= new Data(2);
	m_group.push_back(pdata);
	m_group.push_back(pdata1);
 
 
	cout<<"Group Size:"<<m_group.size()<<endl;
	cout<<"Group capacity():"<<m_group.capacity()<<endl;
 
	for each(auto it in m_group)//手动内存释放
	delete it;
	m_group.clear();
	vector<Data*>().swap(m_group);
	cout<<"Group Size:"<<m_group.size()<<endl;
	cout<<"Group capacity():"<<m_group.capacity()<<endl;
 
	getchar();
	return 0;
 
}	  

运行结果：

其中实际释放过程中 for each( auto iter in m_group ) 里面的 iter 即指的是元素指针可以直接进行内存释放delete iter，不同于迭代器std::iterator ,对于采用迭代器进行指向的 元素 其内存释放过程为 delete (*iter)。