C++中vector的常用操作方法

标准库vector类型是C++中使用较多的一种类模板，vector类型相当于一种动态的容器，在vector中主要有一些基本的操作，下面通过本文给大家介绍，具体内容如下所示：

(1)头文件#include<vector>.

(2)创建vector对象，vector<int> vec;

(3)尾部插入数字：vec.push_back(a);

(4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。

(5)使用迭代器访问元素.

vector<int>::iterator it;

for(it=vec.begin();it!=vec.end();it++)

cout<<*it<<endl;

(6)插入元素： vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;

(7)删除元素：vec.erase(vec.begin()+2);删除第3个元素

vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始

(8)向量大小:vec.size();

(9)清空:vec.clear();

C++ vector类有两种使用方式：

第一种：STL方式

vector< string > text;

1. 我们向 vector 中插入元素，而不再是索引元素，以及向元素赋值，例如 push_back()操作，就是在 vector 的后面插入一个元素下面的 while 循环从标准输入读入一个字符串序列并每次将一个字符串插入到 vector 中  
string word; 
while ( cin >> word ) { 
text.push_back( word ); 
// … 
}

虽然我们仍可以用下标操作符来迭代访问元素  
cout << “words read are: ”; 
 
for ( int ix = 0; ix < text.size(); ++ix ) 
      cout << text[ ix ] << ’ ‘; 
 
cout << endl; 
但是 更典型的做法是使用vector 操作集中的begin()和 end()所返回的迭代器 iterator  
对 ：
cout << “words read are: ”; 
 
for ( vector<string>::iterator it = text.begin(); 
    it != text.end(); ++it ) 
           cout << *it<< ’ ‘; 
 
cout << endl 
iterator 是标准库中的类，它具有指针的功能 

*it; 
对迭代器解引用，并访问其指向的实际对象  
++it;

向前移动迭代器 it 使其指向下一个元素  

2. 注意 不要混用这两种习惯用法， 例如，下面的定义  
vector< int > ivec; 
定义了一个空vector 再写这样的语句  
ivec[ 0 ] = 1024; 
就是错误的 ，因为 ivec 还没有第一个元素，我们只能索引 vector 中已经存在的元素 size()操作返回 vector 包含的元素的个数。

3. 类似地 当我们用一个给定的大小定义一个vector 时，例如  ：
vector<int> ia( 10 ); 
任何一个插入操作都将增加vector 的大小，而不是覆盖掉某个现有的元素，这看起来好像是很显然的，但是下面的错误在初学者中并不少见：
const int size = 7; 
int ia[ size ] = { 0, 1, 1, 2, 3, 5, 8 }; 
vector< int > ivec( size ); 
for ( int ix = 0; ix < size; ++ix ) 
    ivec.push_back( ia[ ix ]); 
程序结束时ivec 包含 14 个元素, ia 的元素从第八个元素开始插入。

第二种：类数组使用

1. 定义一个已知长度的 vector ：

vector< int > ivec( 10 );  //类似数组定义int ia[10 ];

可以通过ivec[索引号] 来访问元素

使用 if ( ivec.empty() ) 判断是否是空，ivec.size()判断元素个数。

2. vector的元素被初始化为与其类型相关的缺省值：算术和指针类型的缺省值是 0，对于class 类型，缺省值可通过调用这类的缺省构造函数获得，我们还可以为每个元素提供一个显式的初始值来完成初始化，例如  
vector< int > ivec( 10, -1 ); 
定义了 ivec 它包含十个int型的元素每个元素都被初始化为-1 

对于内置数组我们可以显式地把数组的元素初始化为一组常量值，例如： 
int ia[ 6 ] = { -2, -1, 0, 1, 2, 1024 };

我们不能用同样的方法显式地初始化 vector ，但是可以将 vector 初始化为一个已有数组的全部或一部分，只需指定希望被用来初始化 vector 的数组的开始地址以及数组最末元的下一位置来实现，例如：  
// 把 ia 的 6 个元素拷贝到 ivec 中 
vector< int > ivec( ia, ia+6 );  

被传递给ivec 的两个指针标记了用来初始化对象的值的范围，第二个指针总是指向要拷贝的末元素的下一位置，标记出来的元素范围也可以是数组的一个子集，例如 :

// 拷贝 3 个元素 ia[2],ia[3], ia[4] 
vector< int > ivec( &ia[ 2 ], &ia[ 5 ] );

3. 与内置数组不同 vector 可以被另一个 vector 初始化或被赋给另一个 vector 例如  
vector< string > svec; 
void init_and_assign() 
{ 
    // 用另一个 vector 初始化一个 vector 
    vector< string > user_names( svec ); 
    // … 
 
    // 把一个 vector 拷贝给另一个 vector 
    svec = user_names; 
}

 三、vector使用总结：

1.vector的初始化：可以有五种方式,举例说明如下：

（1） vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
（2）vector<int>a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
（3）vector<int>a(b); //用b向量来创建a向量，整体复制性赋值
（4）vector<int>a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素
（5）intb[7]={1,2,3,4,5,9,8};vector<int> a(b,b+7); //从数组中获得初值

2.vector对象的几个重要操作，举例说明如下：

（1）a.assign(b.begin(), b.begin()+3);//b为向量，将b的0~2个元素构成的向量赋给a
（2）a.assign(4,2);//是a只含4个元素，且每个元素为2
（3）a.back();//返回a的最后一个元素
（4）a.front();//返回a的第一个元素
（5）a[i]; //返回a的第i个元素，当且仅当a[i]存在2013-12-07
（6）a.clear();//清空a中的元素
（7）a.empty();//判断a是否为空，空则返回ture,不空则返回false
（8）a.pop_back();//删除a向量的最后一个元素
（9）a.erase(a.begin()+1,a.begin()+3);//删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）
（10）a.push_back(5);//在a的最后一个向量后插入一个元素，其值为5
（11）a.insert(a.begin()+1,5);//在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
（12）a.insert(a.begin()+1,3,5);//在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
（13）a.insert(a.begin()+1,b+3,b+6);//b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8，插入元素后为1,4,5,9,2,3,4,5,9,8
（14）a.size();//返回a中元素的个数；
（15）a.capacity();//返回a在内存中总共可以容纳的元素个数
（16）a.rezize(10);//将a的现有元素个数调至10个，多则删，少则补，其值随机
（17）a.rezize(10,2);//将a的现有元素个数调至10个，多则删，少则补，其值为2
（18）a.reserve(100);//将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才 显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能） 
（19）a.swap(b);//b为向量，将a中的元素和b中的元素进行整体性交换
（20）a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<

初始化：

vector<int> a; //声明一个int型向量a
vector<int> a(10); //声明一个初始大小为10的向量
vector<int> a(10, 1); //声明一个初始大小为10且初始值都为1的向量
vector<int> b(a); //声明并用向量a初始化向量b
vector<int> b(a.begin(), a.begin()+3);//将a向量中从第0个到第2个(共3个)作为向量b的初始值
————————————————
int n[] = {1, 2, 3, 4, 5}; vector<int> a(n, n+5); //将数组n的前5个元素作为向量a的初值

vector<int> a(&n[1], &n[4]); //将n[1] - n[4]范围内的元素作为向量a的初值

Vector的基本操作（+-）
a.size() //获取向量中的元素个数
a.empty() //判断向量是否为空
a.clear() //清空向量中的元素
a = b ; //将b向量复制到a向量中
比较
保持 ==、!=、>、>=、<、<= 的惯有含义 ;
如: a == b ; //a向量与b向量比较, 相等则返回1

插入 - insert
①、a.insert(a.begin(), 1000);//将1000插入到向量a的起始位置前

②、a.insert(a.begin(), 3, 1000);//将1000分别插入到向量元素位置的0-2处(共3个元素)

③、 vector<int> a(5, 1) ;
vector<int> b(10) ;
b.insert(b.begin(), a.begin(), a.end()) ; //将a.begin(), a.end()之间的全部元素插入到b.begin()前

删除 - erase
①、b.erase(b.begin());//将起始位置的元素删除
②、b.erase(b.begin(), b.begin()+3);//将(b.begin(), b.begin()+3)之间的元素删除