STL之vector容器详解

vector 容器

vector是C++标准模版库(STL,Standard Template Library)中的部分内容。之所以认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单的说：vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

使用vector容器之前必须加上<vector>头文件：#include<vector>;

vector属于std命名域的内容，因此需要通过命名限定：using std::vector;也可以直接使用全局的命名空间方式：using namespace std;

vector成员函数

c.push_back(elem)在尾部插入一个elem数据。

    vector<int> v;    v.push_back(1);

c.pop_back()删除末尾的数据。

    vector<int> v;    v.pop_back();

c.assign(beg,end)将[beg,end)一个左闭右开区间的数据赋值给c。

vector<int> v1,v2;v1.push_back(10);v1.push_back(20);v2.push_back(30);v2.assign(v1.begin(),v1.end());

c.assign (n,elem)将n个elem的拷贝赋值给c。

vector<int> v;v.assign(5,10);//往v里放5个10

c.at(int index)传回索引为index的数据,如果index越界,抛出out_of_range异常。

vecto<int> v;cout << v.at(2) << endl;//打印vector中下标是2的数据

c.begin()返回指向第一个数据的迭代器。

c.end()返回指向最后一个数据之后的迭代器。

vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);vector<int>::iterator it;for(it = v.begin();it!=v.end();it++){    cout << *it << "\t";}cout << endl;

c.rbegin()返回逆向队列的第一个数据,即c容器的最后一个数据。

c.rend()返回逆向队列的最后一个数据的下一个位置,即c容器的第一个数据再往前的一个位置。

vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);vector<int>::reverse_iterator it;for(it = v.rbegin();it!=v.rend();it++){    cout << *it << "\t";}cout << endl;

c.capacity()返回容器中数据个数,翻倍增长。

capacity 一般大于size的原因是为了避免 每次增加数据时都要重新分配内存，所以一般会 生成一个较大的空间，以便随后的数据插入。

vector<int> v;v.push_back(1);cout << v.capacity() << endl;  // 1v.push_back(2);cout << v.capacity() << endl;  // 2v.push_back(3);cout << v.capacity() << endl; // 4

c.clear()移除容器中的所有数据。

vector<int>::iterator it;for(it = v.begin();it!=v.end();it++){    cout << *it << "\t";}v.clear();for(it = v.begin();it!=v.end();it++){    cout << *it << "\t";}cout << endl;

c.empty()判断容器是否为空。

vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);if(!v.empty()){    cout << "v is not empty!" << endl;        }

c.erase(pos)删除pos位置的数据,传回下一个数据的位置。

vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);v.erase(v.begin());

c.erase(beg,end)删除[beg,end)区间的数据，传回下一个数据的位置。

vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);v.erase(v.begin(),v.end());

c.front()返回第一个数据。

c.back()传回最后一个数据,不检查这个数据是否存在。

vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);if(!vec.empty()){    cout << “the first number is:” << v.front() << endl;    cout << “the last number is:” << v.back() << endl;

c.insert(pos,elem) 在pos位置插入一个elem的拷贝,返回插入的值的迭代器。

c.insert(pos,n,elem)在pos位置插入n个elem的数据,无返回值。

c.insert(pos,beg,end)在pos位置插入在[beg,end)区间的数据,无返回值。

vector<int> v;v.insert(v.begin(),10);v.insert(v.begin(),2,20);v.insert(v.begin(),v1.begin(),v1.begin()+2);

c.size()返回容器中实际数据的个数。

c.resize(num)重新指定队列的长度。（往往用来增加vector的长度,小->大 ok 大->小 没用！）

c.reserve()保留适当的容量。

　　针对resize()和reserver()做一点分析:

　　reserve是容器预留空间，但并不真正创建元素对象，在创建对象之前，不能引用容器内的元素，因此当加入新的元素时，需要用push_back()/insert()函数。

　　resize是改变容器的大小，并且创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用operator[]操作符，或者用迭代器来引用元素对象。

　　再者，两个函数的形式是有区别的，reserve函数之后一个参数，即需要预留的容器的空间；resize函数可以有两个参数，第一个参数是容器新的大小，第二个参数是要加入容器中的新元素，如果这个参数被省略，那么就调用元素对象的默认构造函数。

 　　reserve只是保证vector的空间大小(capacity)最少达到它的参数所指定的大小n。在区间[0, n)范围内，如果下标是index，vector[index]这种访问有可能是合法的，也有可能是非法的，视具体情况而定。
     resize和reserve接口的共同点是它们都保证了vector的空间大小(capacity)最少达到它的参数所指定的大小。

c.max_size()返回容器能容量的最大数量。

c1.swap(c2)将c1和c2交换。

swap(c1,c2)同上。

vector<int> v1,v2,v3;v1.push_back(10);v2.swap(v1);swap(v3,v1);

vector<type>c;创建一个空的vector容器。

vector<type> c1(c2);复制一个vector。

vector<type> c(n);创建一个vector,含有n个数据，数据均以缺省构造产生,即全0；

vector<type> c(n,elem)创建一个vector,含有n个elem的拷贝数据。

vector<type> c(beg,end)创建一个以[beg,end)区间的vector。

~vector<type>()   销毁所有数据,施放内存。

压缩一个臃肿的vector

很多时候大量的删除数据，或者通过使用reserver(),结果vector的空间远远大于实际的需要。所以需要压缩vector到它的实际大小。resize()能增加vector的大小。clear()仅仅移除容器内的数据,不能改变capacity()的大小,所以对vector进行压缩非常重要。

测试一下clear()函数：

////  vector.cpp//  vector////  Created by scandy_yuan on 13-1-7.//  Copyright (c) 2013年 Sam. All rights reserved.//#include <iostream>#include <vector>using namespace std;int main(int argc, const char * argv[]){    // insert code here...    vector<int> v;    v.push_back(1);    v.push_back(2);    v.push_back(3);    vector<int>::iterator it;    cout << "clear before:" << " ";    for(it=v.begin();it!=v.end();it++){        cout << *it << "\t";    }    cout << endl;    cout << "clear before capacity:" << v.capacity() << endl;    v.clear();    cout << "after clear:" << " ";    for(it=v.begin();it!=v.end();it++){        cout << *it << "\t";    }    cout << endl;    cout << "after clear capacity:" << v.capacity() << endl;    return 0;}

结果：

clear before: 1    2    3    clear before capacity:4after clear: after clear capacity:4

为什么这里打印的capacity()的结果是4不做详细解释,请参考上面关于capacity的介绍。 通过结果，我们可以看到clear()之后数据全部清除了,但是capacity()依旧是4。

假设：我们通过原本的vector来创建一个新的vector,让我们看看将会发生什么？

////  vector.cpp//  vector////  Created by scandy_yuan on 13-1-7.//  Copyright (c) 2013年 Sam. All rights reserved.//#include <iostream>#include <vector>using namespace std;int main(int argc, const char * argv[]){    // insert code here...    vector<int> v;    v.push_back(1);    v.push_back(2);    v.push_back(3);    cout << "v.capacity()" << v.capacity() << endl;        vector<int> v1(v);    cout << "v1.capacity()" << v1.capacity() << endl;    return 0;}

结果：

v.capacity()4v1.capacity()3

可以看出,v1的capacity()是v的实际大小，因此可以达到压缩vector的目的。但是我们不想新建一个,我们想在原本的vector(即v)上进行压缩,那么借鉴上面的方式思考另一种方式。

假设:我们通过swap函数把v1交换回v,看看会发生什么？

////  vector.cpp//  vector////  Created by scandy_yuan on 13-1-7.//  Copyright (c) 2013年 Sam. All rights reserved.//#include <iostream>#include <vector>using namespace std;int main(int argc, const char * argv[]){    // insert code here...    vector<int> v;    v.push_back(1);    v.push_back(2);    v.push_back(3);    cout << "v.capacity()" << v.capacity() << endl;        vector<int> v1(v);    cout << "v1.capacity()" << v1.capacity() << endl;        v.swap(v1);    cout << "v.swap(v1).capacity()" << v.capacity() << endl;    return 0;}

结果：

v.capacity()4v1.capacity()3v.swap(v1).capacity()3

可以看出,v.capacity()变成了3,目的达到。但是代码给人感觉繁琐臃肿,我们从新考虑一种新的写法,采用匿名对象来代替v1这个中间对象：vector<int> (v).swap(v);

测试：

////  vector.cpp//  vector////  Created by scandy_yuan on 13-1-7.//  Copyright (c) 2013年 Sam. All rights reserved.//#include <iostream>#include <vector>using namespace std;int main(int argc, const char * argv[]){    // insert code here...    vector<int> v;    v.push_back(1);    v.push_back(2);    v.push_back(3);    cout << "v.capacity()" << v.capacity() << endl;        vector<int> (v).swap(v);    cout << "v.capacity()" << v.capacity() << endl;    return 0;}

结果：

v.capacity()4v.capacity()3

可以看到 v.capacity()由4编程了3,目的达到。

---

之前没有关注C++11,确实在C++11中已经提供了shrink_to_fit()函数实现vector的压缩。

如下：

#include <iostream>#include <vector>int main(){    std::vector<int> v;    std::cout << "Default-constructed capacity is " << v.capacity() << '\n';    v.resize(100);    std::cout << "Capacity of a 100-element vector is " << v.capacity() << '\n';    v.clear();    std::cout << "Capacity after clear() is " << v.capacity() << '\n';    v.shrink_to_fit();    std::cout << "Capacity after shrink_to_fit() is " << v.capacity() << '\n';}

结果：

Default-constructed capacity is 0Capacity of a 100-element vector is 100Capacity after clear() is 100Capacity after shrink_to_fit() is 0

/*******************************************************************************/

在c++中，vector是一个十分有用的容器，下面对这个容器做一下总结。

1 基本操作

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

2

vector的元素不仅仅可以使int,double,string,还可以是结构体，但是要注意：结构体要定义为全局的，否则会出错。下面是一段简短的程序代码：

#include<stdio.h>#include<algorithm>#include<vector>#include<iostream>using namespace std;typedef struct rect{    int id;    int length;    int width;

　　//对于向量元素是结构体的，可在结构体内部定义比较函数，下面按照id,length,width升序排序。
　　bool operator< (const rect &a)  const
    {
        if(id!=a.id)
            return id<a.id;
        else
        {
            if(length!=a.length)
                return length<a.length;
            else
                return width<a.width;
        }
    }}Rect;int main(){    vector<Rect> vec;    Rect rect;    rect.id=1;    rect.length=2;    rect.width=3;    vec.push_back(rect);    vector<Rect>::iterator it=vec.begin();    cout<<(*it).id<<' '<<(*it).length<<' '<<(*it).width<<endl;    return 0;}

 3  算法

(1) 使用reverse将元素翻转：需要头文件#include<algorithm>

reverse(vec.begin(),vec.end());将元素翻转(在vector中，如果一个函数中需要两个迭代器，

一般后一个都不包含.)

(2)使用sort排序：需要头文件#include<algorithm>，

sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).

可以通过重写排序比较函数按照降序比较，如下：

定义排序比较函数：

bool Comp(const int &a,const int &b)
{
    return a>b;
}
调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。

/*******************************************************************************/

学习C++ -> 向量(vector)

一、向量的介绍
    向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版。
    
    在使用它时, 需要包含头文件 vector, #include<vector>
    
    vector 容器与数组相比其优点在于它能够根据需要随时自动调整自身的大小以便容下所要放入的元素。此外, vector 也提供了许多的方法来对自身进行操作。
    
    

 

二、向量的声明及初始化
    vector 型变量的声明以及初始化的形式也有许多, 常用的有以下几种形式:

        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的初值

 

        
        
三、元素的输入及访问
    元素的输入和访问可以像操作普通的数组那样, 用cin>>进行输入, cout<<a[n]这样进行输出:
    示例:

 1     #include<iostream> 2     #include<vector> 3  4     using namespace std ; 5  6     int main() 7     { 8         vector<int> a(10, 0) ;      //大小为10初值为0的向量a 9 10         //对其中部分元素进行输入11         cin >>a[2] ;12         cin >>a[5] ;13         cin >>a[6] ;14 15         //全部输出16         int i ;17         for(i=0; i<a.size(); i++)18             cout<<a[i]<<" " ;19 20         return 0 ;21     }

    
    在元素的输出上, 还可以使用遍历器(又称迭代器)进行输出控制。在 vector<int> b(a.begin(), a.begin()+3) ; 这种声明形式中, (a.begin()、a.begin()+3) 表示向量起始元素位置到起始元素+3之间的元素位置。(a.begin(), a.end())则表示起始元素和最后一个元素之外的元素位置。
    向量元素的位置便成为遍历器, 同时, 向量元素的位置也是一种数据类型, 在向量中遍历器的类型为: vector<int>::iterator。 遍历器不但表示元素位置, 还可以再容器中前后移动。
    
    在上例中讲元素全部输出部分的代码就可以改写为:

    //全部输出    vector<int>::iterator t ;    for(t=a.begin(); t!=a.end(); t++)        cout<<*t<<" " ;

        
    *t 为指针的间接访问形式, 意思是访问t所指向的元素值。
    
    

 

四、向量的基本操作

      1>. a.size()                 //获取向量中的元素个数    2>. a.empty()                //判断向量是否为空    3>. a.clear()                //清空向量中的元素    4>. 复制        a = b ;            //将b向量复制到a向量中    5>. 比较        保持 ==、!=、>、>=、<、<= 的惯有含义 ;        如: a == b ;    //a向量与b向量比较, 相等则返回1    6>. 插入 - 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()前    7>. 删除 - erase        ①、 b.erase(b.begin()) ;                     //将起始位置的元素删除        ②、 b.erase(b.begin(), b.begin()+3) ;        //将(b.begin(), b.begin()+3)之间的元素删除    8>. 交换 - swap        b.swap(a) ;            //a向量与b向量进行交换

 

        
        
五、二维向量
    与数组相同, 向量也可以增加维数, 例如声明一个m*n大小的二维向量方式可以像如下形式:

        vector< vector<int> > b(10, vector<int>(5));        //创建一个10*5的int型二维向量

 
    在这里, 实际上创建的是一个向量中元素为向量的向量。同样可以根据一维向量的相关特性对二维向量进行操作。
    
    例:

 1     #include<iostream> 2     #include<vector> 3  4     using namespace std ; 5  6     int main() 7     { 8         vector< vector<int> > b(10, vector<int>(5, 0)) ; 9 10         //对部分数据进行输入11         cin>>b[1][1] ;12         cin>>b[2][2] ;13         cin>>b[3][3];14 15         //全部输出16         int m, n ;17         for(m=0; m<b.size(); m++)           //b.size()获取行向量的大小18         {19             for(n=0; n<b[m].size(); n++)    //获取向量中具体每个向量的大小20                 cout<<b[m][n]<<" " ;21             cout<<"\n" ;22         }23 24         return 0;25     }

    
    同样, 按照这样的思路我们还可以创建更多维的向量, 不过维数太多会让向量变得难以灵活控制, 三维以上的向量还需酌情使用。

/*******************************************************************************/

c++中vector的学习

根据各种做题，发现数组并不是很适用于各种情况，当涉及到内存占用的时候，数组可能就没有vector的优势了，而vector，动态数组，比较适合某些情况。

接下来看看比较基本的vector用法：

 1 #include<iostream> 2 #include<vector> 3 using namespace std; 4  5 int main() 6 { 7     int i; 8     int A[10]={9,5,8,6,4,2,3,7,0,1}; 9     vector<int> V;10     11     for(i=0;i<10;i++)12     {13         V.push_back(A[i]);14     }15     16     vector<int>::iterator it;17     for(it=V.begin();it!=V.end();it++)18     {19         cout<<*it<<endl;20     } 21     22     return 0;23 } 

这里还用了一个迭代器访问元素。

注意点：

1，引用头文件：#include<vector>

2，创建vector 对象 ： vector<int> V;

3，尾插元素： V.push_back(a[i]);

4，插入元素：  V.insert(V.begin()+i,a); //在第i+1个元素前面插入a

5，删除元素：vec.erase(vec.begin()+i); //删除第i+1个元素

6，求vector的长度：V.size();

 

 

 1 #include<iostream> 2 #include<vector> 3 #include<algorithm>   4 using namespace std; 5  6 int main() 7 { 8     int i; 9     int A[10]={9,5,8,6,4,2,3,7,0,1};10     vector<int> V;11     12     for(i=0;i<10;i++)13     {14         V.push_back(A[i]);15     }16     17     sort(V.begin(),V.end());//排序方法18     19     vector<int>::iterator it;20     for(it=V.begin();it!=V.end();it++)21     {22         cout<<*it<<" ";23     } 24     25     return 0;26 } 

 

在这个基础上，加上 头文件#include<algorithm> 中的sort() 方法，就可以得出排序好了的

这种是升序的，降序的话，sort(vec.begin(),vec.end(),Comp)，这样就降序排序。

百度的Comp：

bool Comp(const int &a,const int &b){    return a>b;}

 

 

主要是以前虽然学过vector，但并没有真正去理解它，以后遇到一些数组处理不过来的问题，会尝试着利用vector的。

 

在PAT中，也有这种题目，我自己编译的话，主要的问题就是段问题，超哥说问题在于我的数组，之前曾写过各种排序算法的性能分析，当时由于想要看到时间，所以定义了一个二维数组，都很大int A[100][1000],记得只能写成这个样子，不然就不能运行了。所以，同理，可能这就是动态数组的好处，只是当时不能熟练地去利用vector这个容器。

下面来看PAT中的题目：

链接：https://www.patest.cn/contests/pat-b-practise/1015

 

这个题目要求的范围也比较大，动态数组用起来就很方便了。

因为我用的是数组，然后逻辑，就是比较排序出了一点点问题，然后就百度了看看：

 1 #include<vector>   2 #include<cstdio>   3 #include<algorithm>   4 using namespace std;   5    6 struct student   7 {   8     int kaohao;   9     int defen;  10     int caifen;  11     int zongfen;  12 };  13   14 bool compare(student a,student b) //比较a在b前则返回true,表示a在b前面  15 {  16     if(a.zongfen>b.zongfen)  17         return true;  18     else if(a.zongfen == b.zongfen)  19     {  20         if(a.defen>b.defen)  21             return true;  22         else if(a.defen==b.defen)  23         {  24             if(a.kaohao<b.kaohao)  25                 return true;  26         }  27     }  28     return false;  29 }  30   31 int main()  32 {  33     vector<student> v1,v2,v3,v4;//表示四类考生  34     student stu;//学生信息临时保存  35     int count=0;//达标的学生总数  36     int N,L,H;  37   38     //cin>>N>>L>>H;  39     scanf("%d %d %d",&N,&L,&H);    40     int K,D,C;  41     while(N--)  42     {  43         //cin>>K>>D>>C;  44         scanf("%d%d%d",&K,&D,&C);    45         stu.kaohao = K;  46         stu.defen = D;  47         stu.caifen = C;  48         stu.zongfen = D+C;  49         if(D>=L && C>=L)  50         {  51             count++;  52             if(D>=H && C>=H)  53                 v1.push_back(stu);    54             else if(D>=H && C<H )  55                 v2.push_back(stu);  56             else if(D<H && C<H  && D>=C)  57                 v3.push_back(stu);  58             else   59                 v4.push_back(stu);  60         }  61       62     }  63     printf("%d\n",count);  64     sort(v1.begin(),v1.end(),compare);  65     sort(v2.begin(),v2.end(),compare);  66     sort(v3.begin(),v3.end(),compare);  67     sort(v4.begin(),v4.end(),compare);  68   69     vector<student>::iterator itr;  70     for(itr=v1.begin();itr!=v1.end();itr++)  71         printf("%d %d %d\n",itr->kaohao,itr->defen,itr->caifen);  72     for(itr=v2.begin();itr!=v2.end();itr++)  73         printf("%d %d %d\n",itr->kaohao,itr->defen,itr->caifen);  74     for(itr=v3.begin();itr!=v3.end();itr++)  75         printf("%d %d %d\n",itr->kaohao,itr->defen,itr->caifen);  76     for(itr=v4.begin();itr!=v4.end();itr++)  77         printf("%d %d %d\n",itr->kaohao,itr->defen,itr->caifen);  78   79     system("pause");  80     return 0;  81 }