vector_vector c++ - CSDN
vector 订阅
Vector类 是在 java 中可以实现自动增长的对象数组,vector在C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。 展开全文
Vector类 是在 java 中可以实现自动增长的对象数组,vector在C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。
信息
外文名
vector
头文件
#include
命名空间
using namespace std
属    性
类库
运用软件
JAVA、C++
vector详细介绍
vector是C++标准模板库中的部分内容,中文偶尔译作“容器”,但并不准确。它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据。 [1]  简单的使用方法如下:我们可以用一个迭代器:vector::iterator iter=test.begin();//定义一个可以迭代int型vector的迭代器iter,它指向test的首位for(;iter!=test.end();iter++) cout<<(*iter);//iter++指的是向后迭代一位,直到iter到超出末端迭代器为止,输出迭代器指向的值我们也可以使用at访问:Java中Vector类是允许不同类型元素共存的变长数组,Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能。在Java语言中是没有指针概念的,但如果能正确灵活地使用指针又确实可以大大提高程序的质量,比如在C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷,Java提供了丰富的类库来方便编程者使用,Vector类便是其中之一。事实上,灵活使用数组也可完成向量类的功能,向量类中提供的大量方法也大大方便了用户的使用。 [2]  在相对于ArrayList来说,Vector线程是安全的,也就是说是同步的。创建了一个向量类的对象后,可以往其中随意地插入不同的类的对象,既不需顾及类型也不需预先选定向量的容量,并可方便地进行查找。对于预先不知或不愿预先定义数组大小,并需频繁进行查找、插入和删除工作的情况,可以考虑使用向量类。向量类提供了三种构造方法: [3]  使用第一种方法,系统会自动对向量对象进行管理。若使用后两种方法,则系统将根据参数initialcapacity设定向量对象的容量(即向量对象可存储数据的大小),当真正存放的数据个数超过容量时,系统会扩充向量对象的存储容量。参数capacityIncrement给定了每次扩充的扩充值。当capacityIncrement为0时,则每次扩充一倍。利用这个功能可以优化存储。在Vector类中提供了各种方法方便用户使用:
收起全文
精华内容
参与话题
  • Vector的详细用法

    千次阅读 多人点赞 2020-01-16 08:35:53
    vector 是向量类型 它可以容纳许多类型的数据,如若干个整数,所以称其为容器。vector 是C++ STL的一个重要成员,使用它时需要包含头文件:#include; 一、vector 的初始化: (1) vector<int> a(10); //定义...

    vector 是向量类型

    它可以容纳许多类型的数据,如若干个整数,所以称其为容器。vector 是C++ STL的一个重要成员,使用它时需要包含头文件:#include;

    一、vector 的初始化:

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

    二、vector对象的几个重要操作:

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

    三、顺序访问vector的几种方式:

    (1)向向量a中添加元素
    1、简单

     vector<int> a;
     for(int i=0;i<10;i++)
     a.push_back(i);
    

    2、从数组中选择元素向向量中添加

    int a[6]={1,2,3,4,5,6};
    vector<int> b;
    for(int i=1;i<=4;i++)
    b.push_back(a[i]);
    

    3、从现有向量中选择元素向向量中添加

    int a[6]={1,2,3,4,5,6};
    vector<int> b;
    vector<int> c(a,a+4);
    for(vector<int>::iterator it=c.begin();it<c.end();it++)
    b.push_back(*it);
    

    4、从文件中读取元素向向量中添加

    ifstream in("data.txt");
    vector<int> a;
    for(int i; in>>i)
        a.push_back(i);
    

    5、【误区】

    vector<int> a;
    for(int i=0;i<10;i++)
        a[i]=i;
    

    //这种做法以及类似的做法都是错误的。刚开始我也犯过这种错误,后来发现,下标只能用于获取已存在的元素,而现在的a[i]还是空的对象。

    (2)从向量中读取元素

    1、通过下标方式读取

    int a[6]={1,2,3,4,5,6};
    vector<int> b(a,a+4);
    for(int i=0;i<=b.size()-1;i++)
        cout<<b[i]<<" ";
    

    2、通过遍历器方式读取

    int a[6]={1,2,3,4,5,6};
    vector<int> b(a,a+4);
    for(vector<int>::iterator it=b.begin();it!=b.end();it++)
        cout<<*it<<" ";
    

    四、几种重要的算法,使用时需要包含头文件:

      #include<algorithm>1sort(a.begin(),a.end()); //对a中的从a.begin()(包括它)到a.end()(不包括它)的元素进行从小到大排列2reverse(a.begin(),a.end()); //对a中的从a.begin()(包括它)到a.end()(不包括它)的元素倒置,但不排列,如a中元素为1,3,2,4,倒置后为4,2,3,13copy(a.begin(),a.end(),b.begin()+1); //把a中的从a.begin()(包括它)到a.end()(不包括它)的元素复制到b中,从b.begin()+1的位置(包括它)开        始复制,覆盖掉原有元素4find(a.begin(),a.end(),10); //在a中的从a.begin()(包括它)到a.end()(不包括它)的元素中查找10,若存在返回其在向量中的位置
    
    展开全文
  • C++_vector操作

    万次阅读 多人点赞 2020-01-03 12:03:02
    vector说明: vector是向量类型,可以容纳许多类型的数据,因此也被称为容器 (可以理解为动态数组,是封装好了的类) vector头文件-vector vector初始化: 方式1. vector<int>a(10);//定义具有10个...

    1. vector:

    1.1 vector 说明

    • vector是向量类型,可以容纳许多类型的数据,因此也被称为容器
    • (可以理解为动态数组,是封装好了的类)
    • 进行vector操作前应添加头文件#include <vector>

    1.2 vector初始化:

    方式1.

    //定义具有10个整型元素的向量(尖括号为元素类型名,它可以是任何合法的数据类型),不具有初值,其值不确定
    vector<int>a(10);
    

    方式2.

    //定义具有10个整型元素的向量,且给出的每个元素初值为1
    vector<int>a(10,1);
    

    方式3.

    //用向量b给向量a赋值,a的值完全等价于b的值
    vector<int>a(b);
    

    方式4.

    //将向量b中从0-2(共三个)的元素赋值给a,a的类型为int型
    vector<int>a(b.begin(),b.begin+3);
    

    方式5.

     //从数组中获得初值
    int b[7]={1,2,3,4,5,6,7};
    vector<int> a(b,b+7;
    

    1.3 vector对象的常用内置函数使用(举例说明)

    #include<vector>
    vector<int> a,b;
    //b为向量,将b的0-2个元素赋值给向量a
    a.assign(b.begin(),b.begin()+3);
    //a含有4个值为2的元素
    a.assign(4,2);
    //返回a的最后一个元素
    a.back();
    //返回a的第一个元素
    a.front();
    //返回a的第i元素,当且仅当a存在
    a[i];
    //清空a中的元素
    a.clear();
    //判断a是否为空,空则返回true,非空则返回false
    a.empty();
    //删除a向量的最后一个元素
    a.pop_back();
    //删除a中第一个(从第0个算起)到第二个元素,也就是说删除的元素从a.begin()+1算起(包括它)一直到a.begin()+3(不包括它)结束
    a.erase(a.begin()+1,a.begin()+3);
    //在a的最后一个向量后插入一个元素,其值为5
    a.push_back(5);
    //在a的第一个元素(从第0个算起)位置插入数值5,
    a.insert(a.begin()+1,5);
    //在a的第一个元素(从第0个算起)位置插入3个数,其值都为5
    a.insert(a.begin()+1,3,5);
    //b为数组,在a的第一个元素(从第0个元素算起)的位置插入b的第三个元素到第5个元素(不包括b+6)
    a.insert(a.begin()+1,b+3,b+6);
    //返回a中元素的个数
    a.size();
    //返回a在内存中总共可以容纳的元素个数
    a.capacity();
    //将a的现有元素个数调整至10个,多则删,少则补,其值随机
    a.resize(10);
    //将a的现有元素个数调整至10个,多则删,少则补,其值为2
    a.resize(10,2);
    //将a的容量扩充至100,
    a.reserve(100);
    //b为向量,将a中的元素和b中的元素整体交换
    a.swap(b);
    //b为向量,向量的比较操作还有 != >= > <= <
    a==b;
    

    2. 顺序访问vector的几种方式,举例说明

    2.1. 对向量a添加元素的几种方式

    1.向向量a中添加元素

    vector<int>a;
    for(int i=0;i<10;++i){a.push_back(i);}
    

    2.从数组中选择元素向向量中添加

    int a[6]={1,2,3,4,5,6};
    vector<int> b;
    for(int i=0;i<=4;++i){b.push_back(a[i]);}
    

    3.从现有向量中选择元素向向量中添加

    int a[6]={1,2,3,4,5,6};
    vector<int>b;
    vector<int>c(a,a+4);
    for(vector<int>::iterator it=c.begin();it<c.end();++it)
    {
    	b.push_back(*it);
    }
    

    4.从文件中读取元素向向量中添加

    ifstream in("data.txt");
    vector<int>a;
    for(int i;in>>i){a.push_back(i);}
    

    5.常见错误赋值方式

    vector<int>a;
    for(int i=0;i<10;++i){a[i]=i;}//下标只能用来获取已经存在的元素
    

    2.2 从向量中读取元素

    1.通过下标方式获取

    int a[6]={1,2,3,4,5,6};
    vector<int>b(a,a+4);
    for(int i=0;i<=b.size()-1;++i){cout<<b[i]<<endl;}
    

    2.通过迭代器方式读取

     int a[6]={1,2,3,4,5,6};
     vector<int>b(a,a+4);
     for(vector<int>::iterator it=b.begin();it!=b.end();it++){cout<<*it<<"  ";}
    

    3.几个常用的算法

     #include<algorithm>
     //对a中的从a.begin()(包括它)到a.end()(不包括它)的元素进行从小到大排列
     sort(a.begin(),a.end());
     //对a中的从a.begin()(包括它)到a.end()(不包括它)的元素倒置,但不排列,如a中元素为1,3,2,4,倒置后为4,2,3,1
     reverse(a.begin(),a.end());
      //把a中的从a.begin()(包括它)到a.end()(不包括它)的元素复制到b中,从b.begin()+1的位置(包括它)开始复制,覆盖掉原有元素
     copy(a.begin(),a.end(),b.begin()+1);
     //在a中的从a.begin()(包括它)到a.end()(不包括它)的元素中查找10,若存在返回其在向量中的位置
      find(a.begin(),a.end(),10);
    
    展开全文
  • C++ vector用法(详解!!函数,实现)

    万次阅读 多人点赞 2016-09-30 01:13:49
    1,简述一下vector的基本操作,它的size,capacity(),clear,reverse,reserve,  push_back等!!! 2,说说,vector的存储特性,是顺序存储还是如同链表般,如果是顺序存储...

    1,简述一下vector的基本操作,它的size,capacity(),clear,reverse,reserve,

      push_back等!!!

    2,说说,vector的存储特性,是顺序存储还是如同链表般,如果是顺序存储的话,那么是如何执行

      erase,insert等函数,???(假如后面的空间不够的话,我们需要合理的算法来重新找出一块

      相应的空间吗???拷贝,回收吗???是不是特别麻烦),如果是链式存储的话,那么它又是如何做到快速

      的访问的(通过下标来的)!!!


    1 基本操作

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

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

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

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

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

        

    <span style="font-size:18px;">vector<int>::iterator it;
    for(it=vec.begin();it!=vec.end();it++)
        cout<<*it<<endl;</span>

    (6)插入元素:    vec.insert(vec.begin()+i,a);在第i个元素后面插入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()   //清空之后,vec.size()为0


    一个简单的程序:

    <span style="font-size:18px;">#include<stdio.h>
    #include<vector>
    #include<iostream>
    using namespace std;
    int main()
    {
            int i=0;
            vector<int> vec;
            for(i=0; i<10; i++)
            {
                    vec.push_back(i);   //10个元素依次进入,结果为10
            }
    
            for(unsigned int i=0; i<vec.size(); i++)
            {
            cout<<"初始化遍历:"<<vec[i]<<endl;
            }
            //结果为:0,1,2,3,4,5,6,7,8,9
            vector<int>::iterator it;
    
            for(it = vec.begin(); it!=vec.end(); it++)
            {
            cout<<"迭代遍历:"<<*it<<endl;
            }
      //结果为:0,1,2,3,4,5,6,7,8,9
       vec.insert(vec.begin()+4,0);
      //结果为:11
            for(unsigned int i=0; i<vec.size(); i++)
            {
            cout<<"插入遍历:"<<vec[i]<<endl;
            }
            //结果为:0,1,2,3,0,4,5,6,7,8,9
            vec.erase(vec.begin()+2);
            for(unsigned int i=0; i<vec.size(); i++)
            {
            cout<<"擦除遍历:"<<vec[i]<<endl;
            }
      //结果为:0,1,3,0,4,5,6,7,8,9
            vec.erase(vec.begin()+3,vec.begin()+5);
      
            for(vector<int>::iterator it = vec.begin(); it!=vec.end(); it++)
            {
            cout<<"迭代遍历:"<<*it<<endl;
            }
            return 0;
    }
    
     
    </span>

    2:

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

    <span style="font-size:18px;">#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;
    
    }</span>

    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),这样就降序排序。




    vector : C++ STL中的顺序容器,封装数组

     

    1. vector容器的内存自增长 

    与其他容器不同,其内存空间只会增长,不会减小。先来看看"C++ Primer"中怎么说:为了支持快速的随机访

    问,vector容器的元素以连续方式存放,每一个元素都紧挨着前一个元素存储。设想一下,当vector添加一个元素时,

    为了满足连续存放这个特性,都需要重新分配空间、拷贝元素、撤销旧空间,这样性能难以接受。因此STL实现者在对

    vector进行内存分配时,其实际分配的容量要比当前所需的空间多一些。就是说,vector容器预留了一些额外的存储

    区,用于存放新添加的元素,这样就不必为每个新元素重新分配整个容器的内存空间。

    关于vector的内存空间,有两个函数需要注意:size()成员指当前拥有的元素个数;capacity()成员指当前(容器必须分

    配新存储空间之前)可以存储的元素个数。reserve()成员可以用来控制容器的预留空间。vector另外一个特性在于它的

    内存空间会自增长,每当vector容器不得不分配新的存储空间时,会以加倍当前容量的分配策略实现重新分配。例如,

    当前capacity为50,当添加第51个元素时,预留空间不够用了,vector容器会重新分配大小为100的内存空间,作为新

    连续存储的位置。


    <span style="font-size:18px;">#include <iostream>
    using namespace std;
    #include <vector>
    
    int main()
    {
            vector<int> arry;
            //arry.reserve(10);
            cout << arry.capacity() <<endl;
            arry.push_back(1);
            cout<<arry.capacity() <<endl;
            arry.push_back(2);
            cout<<arry.capacity() <<endl;
            arry.push_back(3);
            cout<<arry.capacity() <<endl;
    
    }
    </span>
    运行结果:

    当我们将上面的那句注释去掉之后:



    2. vector内存释放

    由于vector的内存占用空间只增不减,比如你首先分配了10,000个字节,然后erase掉后面9,999个,留下一个有效元素,但是内存占

    用仍为10,000个。所有内存空间是在vector析构时候才能被系统回收。empty()用来检测容器是否为空的,clear()可以清空所有元素。

    但是即使clear(),vector所占用的内存空间依然如故,无法保证内存的回收。

    如果需要空间动态缩小,可以考虑使用deque。如果非vector不可,可以用swap()来帮助你释放内存。具体方法如下:

    <span style="font-size:18px;">vector<int> nums; 
    nums.push_back(1);
    nums.push_back(1);
    nums.push_back(2);
    nums.push_back(2); 
    vector<int>().swap(nums); //或者nums.swap(vector<int> ())</span>

    或者如下所示,使用一对大括号,意思一样的:
    <span style="font-size:18px;">//加一对大括号是可以让tmp退出{}的时候自动析构
    { 
        std::vector<int> tmp =   nums;  
        nums.swap(tmp); 
    }
    
    </span>

     swap()是交换函数,使vector离开其自身的作用域,从而强制释放vector所占的内存空间,总而言之,释放vector内存最简单的方法是vector<int>.swap(nums)。当时如果nums是一个类的成员,不能把vector<int>.swap(nums)写进类的析构函数中,否则会导致double free or corruption (fasttop)的错误,原因可能是重复释放内存。标准解决方法如下:
    <span style="font-size:18px;">template < class T >
    void ClearVector( vector< T >& vt ) 
    {
        vector< T > vtTemp; 
        veTemp.swap( vt );
    }</span>

    3. 利用vector释放指针

    如果vector中存放的是指针,那么当vector销毁时,这些指针指向的对象不会被销毁,那么内存就不会被释放。如下面这种情况,vector中的元素时由new操作动态申请出来的对象指针:

    <span style="font-size:18px;">#include <vector> 
    using namespace std; 
    
    vector<void *> v;</span>

    每次new之后调用v.push_back()该指针,在程序退出或者根据需要,用以下代码进行内存的释放:
    <span style="font-size:18px;">for (vector<void *>::iterator it = v.begin(); it != v.end(); it ++) 
        if (NULL != *it) 
        {
            delete *it; 
            *it = NULL;
        }
    v.clear();</span>





    3,

    vector是线性容器,它的元素严格的按照线性序列排序,和动态数组很相似,和数组一样,它的元素存储在一块连续的存储空间中,这也意味着我们不仅可以使用迭代器(iterator)访问元素,还可以使用指针的偏移方式访问,和常规数组不一样的是,vector能够自动存储元素,可以自动增长或缩小存储空间,

    vector的优点:

    1.       可以使用下标访问个别的元素

    2.       迭代器可以按照不同的方式遍历容器

    3.       可以在容器的末尾增加或删除元素

    和数组相比,虽然容器在自动处理容量的大小时会消耗更多的内存,但是容器能提供和数组一样的性能,而且能很好的调整存储空间大小

    和其他标准的顺序容器相比(deques or lists),能更有效访问容器内的元素和在末尾添加和删除元素,在其他位置添加和删除元素,vector则不及其他顺序容器,在迭代器和引用也不比lists支持的好

    容器的大小和容器的容量是有区别的,大小是指元素的个数,容量是分配的内存大小,容量一般等于或大于容器的大小,vector::size()返回容器的大小,vector::capacity()返回容量值,容量多于容器大小的部分用于以防容器的增加使用,每次重新分配内存都会很影响程序的性能,所以一般分配的容量大于容器的大小,若要自己指定分配的容量的大小,则可以使用vector::reserve(),但是规定的值要大于size()值,


    1.构造和复制构造函数

    explicit vector ( const Allocator& = Allocator() );

    explicit vector ( size_type n, const T& value= T(), const Allocator& = Allocator() );

    template <class InputIterator>

    vector ( InputIterator first, InputIterator last, const Allocator& = Allocator() );

    vector ( const vector<T,Allocator>& x );

     

    explicit:是防止隐式转换, Allocator是一种内存分配模式,一般是使用默认的

     

    vector<int> A;  //创建一个空的的容器

    vector<int> B(10,100); //创建一个个元素,每个元素值为

    vector<int> C(B.begin(),B.end()); //使用迭代器,可以取部分元素创建一个新的容器

    vector<int> D(C); //复制构造函数,创建一个完全一样的容器

     

    2.析构函数

     ~vector()

    销毁容器对象并回收了所有分配的内存

     

    3.重载了=符号

    vector<int> E;

    E = B; //使用=符号

    B = vector<int>(); //将B置为空容器

     

     

    4. vector::begin()  返回第一个元素的迭代器

      函数原型:

      iterator begin ();  //返回一个可变迭代器

    const_iterator begin () const; //返回一个常量的迭代器,不可变

     

    5.vector::end()  返回的是越界后的第一个位置,也就是最后一个元素的下一个位置

      iterator end ();

    const_iterator end () const;

     

    6.vector::rbegin() 反序的第一个元素,也就是正序最后一个元素

      reverse_iterator rbegin();

    const_reverse_iterator rbegin() const;

     

    7.vector::rend() 反序的最后一个元素下一个位置,也相当于正序的第一个元素前一个位置

      reverse_iterator rend();

    const_reverse_iterator rend() const;

    和vector::end()原理一样

     

    8.vector::size() 返回容器中元素个数

      size_type size() const;

      注意与vector::capacity()的区别

     

    9.vector::max_size()

      size_type max_size () const;

      返回容器的最大可以存储的元素个数,这是个极限,当容器扩展到这个最大值时就不能再自动增大

     

    10. vector::resize()

      void resize ( size_type sz, T c = T() );

      重新分配容器的元素个数,这个还可以改容器的容量,如果重新分配的元素个数比原来的小,将截断序列,后面的部分丢弃,如果大于原来的个数,后面的值是c的值,默认为0

     

    11. vector::capacity()

       size_type capacity () const;

       返回vector的实际存储空间的大小,这个一般大于或等于vector元素个数,注意与size()函数的区别

     

    12. vector::empty()

       bool empty () const;

       当元素个数为0时返回true,否则为false,根据的是元素个数而不是容器的存储空间的大小

     

     

    13. vector::reserve()

       void reserve ( size_type n );

    重新分配空间的大小,不过这个n值要比原来的capacity()返回的值大,不然存储空间保持不变,n值要比原来的实际存储空间大才能重新分配空间,但是最大值不可以大于max_size的值,否则会抛出异常

     

    14. vector::operator[]  //重载了[]符号

       reference  operator[] ( size_type n );

    const_reference  operator[] ( size_type n ) const;

    实现了下标访问元素

     

    15. vector::at()

       const_reference at ( size_type n ) const;

       reference at ( size_type n );

       在函数的操作方面和下标访问元素一样,不同的是当这个函数越界时会抛出一个异常out_of_range

     

    16. vector::front()

       reference front ( );

    const_reference front ( ) const;

    返回第一个元素的值,与begin()函数有区别,begin()函数返回的是第一个元素的迭代器

     

    17. vector::back()

       reference back ( );

    const_reference back ( ) const;

    同样,返回最后一个元素的值,注意与end()函数的区别

     

    18. vector::assign()

       template <class InputIterator> void assign ( InputIterator first, InputIterator last );

    void assign ( size_type n, const T& u );

    将丢弃原来的元素然后重新分配元素,第一个函数是使用迭代器,第二个函数是使用n个元素,每个元素的值为u。

     

    19. vector::push_back()

       void push_back ( const T& x );

       在容器的最后一个位置插入元素x,如果size值大于capacity值,则将重新分配空间

     

    20. vector::pop_back()

       void pop_back ( );

       删除最后一个元素

     

     

    21. vector::insert()

       iterator insert ( iterator position, const T& x );

       void insert ( iterator position, size_type n, const T& x );

    template <class InputIterator>

    void insert ( iterator position, InputIterator first, InputIterator last );

       插入新的元素,

    第一个函数,在迭代器指定的位置前插入值为x的元素

    第二个函数,在迭代器指定的位置前插入n个值为x的元素

    第三个函数,在迭代器指定的位置前插入另外一个容器的一段序列迭代器first到last

    若插入新的元素后总得元素个数大于capacity,则重新分配空间

     

    22. vector::erase()

       iterator erase ( iterator position );

    iterator erase ( iterator first, iterator last );

    删除元素或一段序列

     

    23. vector::swap()

       void swap ( vector<T,Allocator>& vec );

       交换这两个容器的内容,这涉及到存储空间的重新分配

     

    24. vector::clear()

       void clear ( );

       将容器里的内容清空,size值为0,但是存储空间没有改变


    <span style="font-size:18px;">#include <vector>
    #include <iostream>
    using namespace std;
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    
            //构造函数,复制构造函数(元素类型要一致),
        vector<int> A;  //创建一个空的的容器
        vector<int> B(10,100); //创建一个10个元素,每个元素值为100
        vector<int> C(B.begin(),B.end()); //使用迭代器,可以取部分元素创建一个新的容器
        vector<int> D(C); //复制构造函数,创建一个完全一样的容器
        
              //重载=
        vector<int> E;
        E = B;
     
        //vector::begin(),返回的是迭代器
       
        vector<int> F(10); //创建一个有10个元素的容器
               for (int i = 0; i < 10; i++)
              {
            F[i] = i;
              }
    
        /*
        vector<int> F; //创建一个空容器
        for (int i = 0; i < 10; i++)
        {
            F.push_back(i);
        } 
            */
    
        vector<int>::iterator BeginIter = F.begin();
        cout << *BeginIter << endl; //输出0
    
        //vector::end() 返回迭代器
        vector<int>::iterator EndIter = F.end();
        EndIter--; //向后移一个位置
        cout << *EndIter << endl; //输出9
     
        //vector::rbegin() 返回倒序的第一个元素,相当于最后一个元素
        vector<int>::reverse_iterator ReverBeIter = F.rbegin();
        cout << *ReverBeIter << endl; //输出9
    
        //vector::rend() 反序的最后一个元素下一个位置,也相当于正序的第一个元素前一个位置
        vector<int>::reverse_iterator ReverEnIter = F.rend();
        ReverEnIter--;
        cout << *ReverEnIter << endl; //输出0
    
        //vector::size() 返回元素的个数
        cout << F.size() << endl; //输出10
    
        //vector::max_size()
        cout << F.max_size() << endl; //输出1073741823,这个是极限元素个数
    
        //vector::resize()
        cout << F.size() << endl; //输出10
        F.resize(5);
        for(int k = 0; k < F.size(); k++)
            cout << F[k] << "  "; //输出 0 1 2 3 4
             cout << endl;
        
        //vector::capacity()
        cout << F.size() << endl; //5
        cout << F.capacity() << endl; //10
    
        //vector::empty()
             B.resize(0);
        cout << B.size() << endl; //0
        cout << B.capacity() << endl; //10
        cout << B.empty() << endl; //true
    
        //vector::reserve() //重新分配存储空间大小
               cout << C.capacity() << endl; //10
        C.reserve(4);
        cout << C.capacity() << endl; //10
        C.reserve(14);
        cout << C.capacity() << endl; //14
    
        //vector::operator []
        cout << F[0] << endl; //第一个元素是0
    
        //vector::at()
        try
        {
          cout << "F.size = " << F.size() << endl; //5
               cout << F.at(6) << endl; //抛出异常
        }
        catch(out_of_range)
        {    
           cout << "at()访问越界" << endl;
        }
    
        //vector::front() 返回第一个元素的值
               cout << F.front() << endl; //0
    
        //vector::back()
        cout << F.back() << endl; //4
    
        //vector::assign()
        cout << A.size() << endl; //0
        vector<int>::iterator First = C.begin();
        vector<int>::iterator End = C.end()-2;
        A.assign(First,End);
        cout << A.size() << endl; //8
        cout << A.capacity() << endl; //8
    
        A.assign(5,3); //将丢弃原来的所有元素然后重新赋值
        cout << A.size() << endl; //5
        cout << A.capacity() << endl; //8
    
        //vector::push_back()
        cout << *(F.end()-1) << endl; //4
        F.push_back(100);
        cout << *(F.end()-1) << endl; //100
    
        //vector::pop_back()
        cout << *(F.end()-1) << endl; //100
        F.pop_back();
        cout << *(F.end()-1) << endl; //4
    
        //vector::swap()
        F.swap(D); //交换这两个容器的内容
        for(int f = 0; f < F.size(); f++)
            cout << F[f] << " ";
        cout << endl;
        for (int d = 0; d < D.size(); d++)
            cout << D[d] << " ";
             cout << endl;
        //vector::clear()
        F.clear();
        cout << F.size() << endl;     //0
        cout << F.capacity() << endl; //10
    
        return 0;
    }
    
    
    </span>



    本文借鉴与:http://www.cnblogs.com/wang7/archive/2012/04/27/2474138.html

                         http://blog.csdn.net/bizhu12/article/details/6769976

          http://www.cnblogs.com/summerRQ/articles/2407974.html

    展开全文
  • vector类 的属性和用法

    万次阅读 2018-08-22 13:07:30
    vector简介  vector是STL中最常见的容器,它是一种顺序容器,支持随机访问。vector是一块连续分配的内存,从数据安排的角度来讲,和数组极其相似,不同的地方就是:数组是静态分配空间,一旦分配了空间的大小,就...

    vector简介

           vector是STL中最常见的容器,它是一种顺序容器,支持随机访问。vector是一块连续分配的内存,从数据安排的角度来讲,和数组极其相似,不同的地方就是:数组是静态分配空间,一旦分配了空间的大小,就不可再改变了;而vector是动态分配空间,随着元素的不断插入,它会按照自身的一套机制不断扩充自身的容量。

            vector的扩充机制:按照容器现在容量的一倍进行增长。vector容器分配的是一块连续的内存空间,每次容器的增长,并不是在原有连续的内存空间后再进行简单的叠加,而是重新申请一块更大的新内存,并把现有容器中的元素逐个复制过去,然后销毁旧的内存。这时原有指向旧内存空间的迭代器已经失效,所以当操作容器时,迭代器要及时更新。

    vector的数据结构

            vector数据结构,采用的是连续的线性空间,属于线性存储。他采用3个迭代器_First、_Last、_End来指向分配来的线性空间的不同范围,下面是声明3个迭代器变量的源代码。

    template<class _Ty, class _A= allocator< _Ty> > 
    class vector{ 
        ... 
        protected: 
        iterator _First, _Last, _End; 
    };

    _First指向使用空间的头部,_Last指向使用空间大小(size)的尾部,_End指向使用空间容量(capacity)的尾部。例如:

    int data[6]={3,5,7,9,2,4}; 
    vector<int> vdata(data, data+6); 
    vdata.push_back(6); 
    ...

    vector初始化时,申请的空间大小为6,存放下了data中的6个元素。当向vdata中插入第7个元素“6”时,vector利用自己的扩充机制重新申请空间,数据存放结构如图1所示:

     

    图1 扩充后的vector内存结构

            简单描述一下。当插入第7个元素“6”时,vector发现自己的空间不够了,于是申请新的大小为12的内存空间(自增一倍),并将前面已有数据复制到新空间的前部,然后插入第7个元素。此时_Last迭代器指向最后一个有效元素,而_End迭代器指向vector的最后有效空间位置。我们利用vector的成员函数size可以获得当前vector的大小,此时为7;利用capacity成员函数获取当前vector的容量,此时为12。

    
     
    vector容器类型

       vector容器是一个模板类,可以存放任何类型的对象(但必须是同一类对象)。vector对象可以在运行时高效地添加元素,并且vector中元素是连续存储的。

    vector的构造

     

    函数原型:

    template<typename T>
       explicit vector();                                 // 默认构造函数,vector对象为空
       explicit vector(size_type n, const T& v = T());    // 创建有n个元素的vector对象
       vector(const vector& x);
       vector(const_iterator first, const_iterator last);


    注:vector容器内存放的所有对象都是经过初始化的。如果没有指定存储对象的初始值,那么对于内置类型将用0初始化,对于类类型将调用其默认构造函数进行初始化(如果有其它构造函数而没有默认构造函数,那么此时必须提供元素初始值才能放入容器中)。

     

    举例:
    vector<string> v1;         // 创建空容器,其对象类型为string类
    vector<string> v2(10);     // 创建有10个具有初始值(即空串)的string类对象的容器
    vector<string> v3(5, "hello"); // 创建有5个值为“hello”的string类对象的容器
    vector<string> v4(v3.begin(), v3.end());  // v4是与v3相同的容器(完全复制)

     

    vector的操作(下面的函数都是成员函数)
     
    bool empty() const;                    // 如果为容器为空,返回true;否则返回false
    size_type max_size() const;            // 返回容器能容纳的最大元素个数
    size_type size() const;                // 返回容器中元素个数  
    size_type capacity() const;            // 容器能够存储的元素个数,有:capacity() >= size()  
    void reserve(size_type n);             // 确保capacity() >= n
    void resize(size_type n, T x = T());   // 确保返回后,有:size() == n;如果之前size()<n,那么用元素x的值补全。

     

    reference front();                     // 返回容器中第一个元素的引用(容器必须非空)
    const_reference front() const;                   
    reference back();                      // 返回容器中最后一个元素的引用(容器必须非空)
    const_reference back() const;

     

    reference operator[](size_type pos);   // 返回下标为pos的元素的引用(下标从0开始;如果下标不正确,则属于未定义行为。
    const_reference operator[](size_type pos) const; 
    reference at(size_type pos);           // 返回下标为pos的元素的引用;如果下标不正确,则抛出异常out_of_range
    const_reference at(size_type pos) const;
                
    void push_back(const T& x);            // 向容器末尾添加一个元素          
    void pop_back();                       // 弹出容器中最后一个元素(容器必须非空)

     

    // 注:下面的插入和删除操作将发生元素的移动(为了保持连续存储的性质),所以之前的迭代器可能失效
    iterator insert(iterator it, const T& x = T());        // 在插入点元素之前插入元素(或者说在插入点插入元素)
    void insert(iterator it, size_type n, const T& x);     // 注意迭代器可能不再有效(可能重新分配空间)
    void insert(iterator it, const_iterator first, const_iterator last);

     

    iterator erase(iterator it);           // 删除指定元素,并返回删除元素后一个元素的位置(如果无元素,返回end())
    iterator erase(iterator first, iterator last); // 注意:删除元素后,删除点之后的元素对应的迭代器不再有效。

     

    void clear() const;                    // 清空容器,相当于调用erase( begin(), end())

     

    void assign(size_type n, const T& x = T());   // 赋值,用指定元素序列替换容器内所有元素
    void assign(const_iterator first, const_iterator last);

     

    const_iterator begin() const;          // 迭代序列
    iterator begin();
    const_iterator end() const;
    iterator end();

     

    const_reverse_iterator rbegin() const;
    reverse_iterator rbegin();
    const_reverse_iterator rend() const; 
    reverse_iterator rend();

     

    vector对象的比较(非成员函数)

     

       针对vector对象的比较有六个比较运算符:operator==、operator!=、operator<、operator<=、operator>、operator>=。

     

       其中,对于operator==和operator!=,如果vector对象拥有相同的元素个数,并且对应位置的元素全部相等,则两个vector对象相等;否则不等。

       对于operator<、operator<=、operator>、operator>=,采用字典排序策略比较。


    注:其实只需要实现operator==和operator!=就可以了,其它可以根据这两个实现。因为,operator!= (lhs, rhs) 就是 !(lhs == rhs),operator<=(lhs, rhs) 就是 !(rhs < lhs),operator>(lhs, rhs) 就是 (rhs < lhs),operator>=(lhs, rhs) 就是 !(lhs, rhs)。

     

    vector类的迭代器


       vector类的迭代器除了支持通用的前缀自增运算符外,还支持算术运算:it + n、it - n、it2 - it1。注意it2 - it1返回值为difference_type(signed类型)。

     

       注意,任何改变容器大小的操作都可能造成以前的迭代器失效。

     

    应用示例

    1.vector 的数据的存入和输出:
    #include<stdio.h>
    #include<vector>
    #include <iostream>
    using namespace std;
    void main()
    {
       int i = 0;
        vector<int> v;
        for( i = 0; i < 10; i++ )
       {
                 v.push_back( i );//把元素一个一个存入到vector中
       }
       for( i = 0; i < v.size(); i++ )//v.size() 表示vector存入元素的个数
       {
              cout << v[ i ] << "  "; //把每个元素显示出来
       }
       cout << endl;
    } 
    注:你也可以用v.begin()和v.end() 来得到vector开始的和结束的元素地址的指针位置。你也可以这样做:
    vector<int>::iterator iter;
    for( iter = v.begin(); iter != v.end(); iter++ )
    {
        cout << *iter << endl;
    }
    2. 对于二维vector的定义。
    1)定义一个10个vector元素,并对每个vector符值1-10。
    #include<stdio.h>
    #include<vector>
    #include <iostream>
    using namespace std;
    void main()
    {
     int i = 0, j = 0;
    //定义一个二维的动态数组,有10行,每一行是一个用一个vector存储这一行的数据。
    所以每一行的长度是可以变化的。之所以用到vector<int>(0)是对vector初始化,否则不能对vector存入元素。
     vector< vector<int> > Array( 10, vector<int>(0) ); 
    for( j = 0; j < 10; j++ )
     {
      for ( i = 0; i < 9; i++ )
      {
       Array[ j ].push_back( i );
      }
     }
     for( j = 0; j < 10; j++ )
     {
      for( i = 0; i < Array[ j ].size(); i++ )
      {
       cout << Array[ j ][ i ] << "  ";
      }
      cout<< endl;
     }
    }
    2)定义一个行列都是变化的数组。
    #include<stdio.h>
    #include<vector>
    #include <iostream>
    using namespace std;
    void main()
    {
     int i = 0, j = 0;
     vector< vector<int> > Array;
     vector< int > line;
     for( j = 0; j < 10; j++ )
     {
      Array.push_back( line );//要对每一个vector初始化,否则不能存入元素。
      for ( i = 0; i < 9; i++ )
      {
       Array[ j ].push_back( i );
      }
     }
     for( j = 0; j < 10; j++ )
     {
      for( i = 0; i < Array[ j ].size(); i++ )
      {
       cout << Array[ j ][ i ] << "  ";
      }
      cout<< endl;
     }
    }
    3.综合一点的例子。
    #include <iostream>
    #include <cassert>
    #include <vector>
    
    
    using namespace std;
    
    
    int main()
    {
        vector<int> v(5, 1);
        vector<int> v2(v.begin(), v.end());
        
        assert(v == v2);
        
        cout<<"> Before operation"<<endl;
        for(vector<int>::const_iterator it = v.begin(); it < v.end(); ++it)
            cout<<*it<<endl;
    
    
        //v.insert(v.begin() + 3, 4, 2);
    
    
        v.insert(v.begin() + 3, 1, 2);
        v.insert(v.begin() + 4, 1, 3);
        v.insert(v.begin() + 5, 1, 4);
        v.insert(v.begin() + 6, 1, 5);
        cout<<"> After insert"<<endl;
        for(vector<int>::size_type i = 0; i < v.size(); ++i)
            cout<<v[i]<<endl;
        
        vector<int>::iterator it1 = v.erase(v.begin() + 3, v.begin() + 6);//删除的是第4,5,6三个元素
        assert(*it1 == 5);
        cout<<"> After erase"<<endl;
        for(vector<int>::size_type j = 0; j != v.size(); ++j)
            cout<<v[j]<<endl;
        
        assert(v.begin() + v.size() == v.end());
        assert(v.end() - v.size() == v.begin());
        assert(v.begin() - v.end() == -vector<string>::difference_type(v.size()));
        
        return 0;
    }


    程序说明:上面第3个程序中用了三个循环输出容器中的元素,每个循环的遍历方式是不一样的。特别需要说明的是,第二个循环在条件判断中使用了size() 函数,而不是在循环之前先保存在变量中再使用。之所以这样做,有两个原因:其一,如果将来在修改程序时,在循环中修改了容器元素个数,这个循环仍然能很好 地工作,而如果先保存size()函数值就不正确了;其二,由于这些小函数(其实现只需要一条返回语句)基本上都被声明为inline,所以不需要考虑效率问题。

     

    vector是一个标准库中的容器,使用时需要包含#include <vector>头文件。

     

    vector是一个类模板而不是一种数据类型,对它的定义,需要指定类型。

    vector(向量)是 C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,

    当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.

     

    1、vector对象的定义和初始化

    vector类定义了好几种构造函数,并且与string类型相类似,如下所示:

    操作调用方式

    操作说明

    Vector<T> v1;

    Vector保存类型为T的对象。默认构造函数v1为空

    Vector<T> v2(v1);

    V2是v1的一个副本

    Vector<T> v3(n , i);

    V3包含n个值为i的元素

    Vector<T> v4(n);

    V4含有值初始化的元素的n个副本

     

    注:对C++的容器来说,动态添加元素的效率,要比直接静态初始化元素的效率高

     

    例1.1 :声明一个int向量以替代一维的数组:vector <int> a;(等于声明了一个int数组a[],大小没有指定,可以动态的向里面添加删除)。

    例1.2: 用vector代替二维数组.其实只要声明一个一维数组向量即可,而一个数组的名字其实代表的是它的首地址,所以只要声明一个地址的向量即可,即:vector <int *> a.同理想用向量代替三维数组也是一样,vector <int**>a;再往上面依此类推.

     

     

    备注:

    在用vector的过程中我碰到了一个问题,特此列出讨论:

      1)

                         vector <int > a;

                         int b = 5;

                         a.push_back(b);

                         此时若对b另外赋值时不会影响a[0]的值

        2)

                        vector <int*> a;
                          int *b;
                          b= new int[4];
                          b[0]=0;
                          b[1]=1;
                          b[2]=2;
                          a.push_back(b);
                          delete b;          //释放b的地址空间
                          for(int i=0 ; i <3 ; i++)
                          {
                                cout<<a[0][i]<<endl;
                          }

                          此时输出的值并不是一开始b数组初始化的值,而是一些无法预计的值.

                         分析:根据1) 2)的结果,可以想到,在1)中,   往a向量中压入的是b的值,即a[0]=b,此时a[0]和b是存储在两个不同的地址中的.因此改变b的值不会影响a[0];而在2)中,因为是把一个地址(指针)压入向量a,即a[0]=b,因此释放了b的地址也就释放了a[0]的地址,因此a[0]数组中存放的数值也就不得而知了.       

     

    2、vector对象的操作

    vector标准库提供了许多类似于string对象的操作,如下所示是一部分:

    操作调用方式

    操作说明

    v.empty()

    判断v是否为空

    v.size()

    返回v中元素的个数

    v.push_back(t)

    向v的末尾添加一个元素

    V[n]

    返回v中位置为n的元素

    V1 = v2

    把v1中元素替换为v2中元素副本

    V1==v2

    判断是否相等

    !=, <, <=, >, >=

    直接用于vector对象的相互比较

     

    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交换数据

     

    注,以下是一些需要注意的地方

    Ø vector和string一样,长度、下标等类型是size_type,但是vector获取size_type时,需要指定类型,如vector<int>::size_type这样的方式

    Ø vector的下标操作,例如v[i],只能用于操作已经存在的元素,可以进行覆盖、获取等,但是不能通过v[i++]这种方式来给一个vector容器添加元素,该功能需要用push_back操作完成,下标不具备该功能

    Ø C++程序员习惯优先使用!=而不是<来编写循环判断条件

     

     

    附录2

     

    C++ vector 排序

     

    C++中当 vector 中的数据类型为基本类型时我们调用std::sort函数很容易实现 vector中数据成员的升序和降序排序,然而当vector中的数据类型为自定义结构体类型时,我们该怎样实现升序与降序排列呢?有两种方法,下面的例子能很好的说明: 方法1:
    我们直接来看代码吧,比较简单,容易理解:

    #include “stdafx.h”
    #include <vector>
    #include <algorithm>
    #include <functional>
    
    using namespace std;
    struct AssessTypeInfo
    {
    unsigned int m_uiType; //类型ID
    char m_szName[64]; //类型名称
    unsigned int m_uiTotal; //总分数
    
    bool operator < (const AssessTypeInfo& rhs ) const //升序排序时必须写的函数
    {
    return m_uiType < rhs.m_uiType;
    }
    bool operator > (const AssessTypeInfo& rhs ) const //降序排序时必须写的函数
    {
    return m_uiType > rhs.m_uiType;
    }
    }
    int main()
    {
    vector<AssessTypeInfo > ctn ;
    
    AssessTypeInfo a1;
    a1.m_uiType=1;
    AssessTypeInfo a2;
    a2.m_uiType=2;
    
    AssessTypeInfo a3;
    a3.m_uiType=3;
    
    ctn.push_back(a1);
    ctn.push_back(a2);
    ctn.push_back(a3);
    //升序排序
    sort(ctn.begin(), ctn.end(),less<AssessTypeInfo>()) ; //或者sort(ctn.begin(), ctn.end()) 默认情况为升序
    
    for ( int i=0; i<3; i++ )
    printf(”%d\n”,ctn[i].m_uiType);
    
    //降序排序
    sort(ctn.begin(), ctn.end(),greater<AssessTypeInfo>()) ;
    
    for ( int i=0; i<3; i++ )
    printf(”%d\n”,ctn[i].m_uiType);
    
    return 0 ;
    }
    以上方法就可以实现升序排序,输出结果为 1 2 3
    降序排序结果3 2 1。
    方法2 : 不修改结构体或类的定义部分,我们用函数对象来实现:
    #include “stdafx.h”
    #include <vector>
    #include <algorithm>
    #include <functional>
    
    using namespace std;
    struct AssessTypeInfo
    {
    unsigned int m_uiType; //类型ID
    char m_szName[64]; //类型名称
    unsigned int m_uiTotal; //总分数
    };
    
    bool lessmark(const AssessTypeInfo& s1,const AssessTypeInfo& s2)
    {
    return s1.m_uiType < s2.m_uiType;
    }
    bool greatermark(const AssessTypeInfo& s1,const AssessTypeInfo& s2)
    {
    return s1.m_uiType > s2.m_uiType;
    }
    int main()
    {
    vector<AssessTypeInfo > ctn ;
    
    AssessTypeInfo a1;
    a1.m_uiType=1;
    AssessTypeInfo a2;
    a2.m_uiType=2;
    
    AssessTypeInfo a3;
    a3.m_uiType=3;
    
    ctn.push_back(a1);
    ctn.push_back(a2);
    ctn.push_back(a3);
    
    sort(ctn.begin(), ctn.end(),lessmark) ; //升序排序
    
    for ( int i=0; i<3; i++ )
    printf(”%d\n”,ctn[i].m_uiType);
    
    sort(ctn.begin(), ctn.end(),greatermark) ; //降序排序
    
    return 0 ;
    }

    以上方法就可以实现升序排序,输出结果为 1 2 3
    降序排序结果3 2 1。
    方法2是一种比较简单的方法。
    以上两种方法您可根据您自己的需求选择,并且以上两种方法在VC++6.0环境下编译通过,也是自己在实践过程中的总结,如有不妥的地方,欢迎您指出,至于为什么这样使用,请参考 stl算法中sort 部分。

    (6)C++ Vector排序

    1. vector< int > vi ;   
    2. vi.push_back(1);  
    3. vi.push_back(3);  
    4. vi.push_back(0);  
    5. sort(vi.begin() , vi.end()); /// /小到大  
    6. reverse(vi.begin(),vi.end()) /// 从大道小 

    (7)顺序访问

    1. vector < int > vi ;   
    2. for( int i = 0 ; i < 10 ; i ++)  
    3. {  
    4. vector.push_back(i);  
    5. }   
    6. for(int i = 0 ; i < 10 ; i ++) /// 第一种调用方法  
    7. {  
    8. cout <<vector[i] <<" " ;   
    9. }  
    10. for(vector<int>::iterator it = vi.begin() ; 
    11. it !=vi.end() ; it++) ///第二种调用方法  
    12. {  
    13. cout << *it << " " ;  

    (8)寻找

    1. vector < int > vi ;   
    2. for( int i = 0 ; i < 10 ; i ++)  
    3. {  
    4. vector.push_back(i);  
    5. }   
    6. vector < int >::interator it = find(vi.begin() , vi.end,3) ;  
    7. cout << *it << endl ; ///返回容器内找到值的位置。 

    (9)使用数组对C++ Vector进行初始化

    1. int i[10] ={1,2,3,4,5,6,7,78,8} ;  
    2. ///第一种   
    3. vector<int> vi(i+1,i+3); ///从第2个元素到第三个元素  
    4. for(vector <int>::interator it = vi.begin() ; 
    5. it != vi.end() ; it++)  
    6. {  
    7. cout << *it <<" " ;   

    (10) 结构体类型

      1. struct temp  
      2. {  
      3. public :  
      4. string str ;   
      5. public :  
      6. int id ;  
      7. }tmp  
      8. int main()  
      9. {  
      10. vector <temp> t ;   
      11. temp w1 ;   
      12. w1.str = "Hellowor" ;  
      13. w1.id = 1 ;   
      14. t.push_back(t1);  
      15. cout << w1.str << "," <<w1.id <<endl ;   
      16. return 0 ;   
    展开全文
  • vector

    2019-11-14 22:36:08
    vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的. 前提: #include<vector> using ...
  • vector采用一段连续的内存来存储其元素,向vector添加元素的时候,如果容量不足,vector便会重新malloc一段更大的内存,然后把原内存中的数据memcpy到新的内存中,并free原内存块,然后将新元素加入。vector的元素...
  • unordered_set可以把它想象成一个集合,它提供了几个函数让我们可以增删查: unordered_set::insert unordered_set::find unordered_set::erase 这个unorder暗示着,这两个头文件中类的底层实现----Hash。...
  • unordered_set可以把它想象成一个集合,它提供了几个函数让我们可以增删查: unordered_set::insert unordered_set::find unordered_set::erase 这个unorder暗示着,这两个头文件中类的底层实现----Hash。...
  • C++ 中vector的使用方法

    万次阅读 多人点赞 2016-06-15 10:54:44
    C++ 中vector的使用方法(纯干货!)
  • C++vector的使用总结及常用vector操作

    万次阅读 多人点赞 2017-10-28 21:22:56
    C++ vector类为内置数组提供了一种替代表示,与string类一样 vector 类是随标准 C++引入的标准库的一部分,使用时需包含头文件: #include C++ vector类有两种使用方式: 第一种:STL方式 vector text; 1. 我们向 ...
  • C++之vector入门

    千次阅读 多人点赞 2020-04-10 22:18:50
    文章目录一、头文件 一、头文件 在std中,所以只用打 using namespace std;
  • Vector 把一个vector追加到另一个vector

    万次阅读 2018-09-15 09:00:18
    把一个vector里的元素追加放入另外一个vector std::vector&lt;int&gt; src; std::vector&lt;int&gt; dest; dest.insert(dest.end(), src.begin(), src.end()); 插到其他位置同理,只需要改变第一...
  • c++ vector反转reverse

    万次阅读 2013-01-02 18:58:38
    template void reverse ( BidirectionalIterator first, BidirectionalIterator last); 如果不是改变原来的容器,而是翻转之后放在新容器里面,直接用reverse_copy ( BidirectionalIterator first, ...
  • C++获得vector最后一个元素

    万次阅读 2019-09-16 11:34:49
    std::vector<int> intVector; intVector[intVector.size() - 1]; // 方式1 intVector.end(); // 方式2
  • C++——二维vector初始化大小方法

    万次阅读 多人点赞 2017-08-05 13:33:17
    初始化二维vector,为r*c的vector,所有值为0.1.直接用初始化方法(刚开始没想到) vector<vector<int>> newOne(r, vector(c, 0));2.用resize()来控制大小 vector<vector<int> > res; res.resize(r);//r行 for ...
  • c++ vector指针访问vector元素的方法

    万次阅读 2017-07-12 10:29:50
    c++使用 vector指针访问vector元素时,不能简单的类似于c中数组和指针的方式。需要使用迭代器。int main() { vector s; vector *p = &s; s.push_back(1); for (vector::iterator it = p->begin(); it != p->end...
  • C++ 中如何用 vector类作为函数的参数

    万次阅读 热门讨论 2010-12-10 16:41:00
    今天学些了C++中的vector容器,如何让vector作为参数呢?贴出我的代码:   #include //vector 是C++中最常用的容器类 #include<vector> using namespace std; void main(){ //注意:在...
  • vector::clear ()方法的使用细节

    万次阅读 2016-02-25 21:04:17
    原型: #include <vector> void clear(): 函数clear()删除储存在vector中的所有元素.
  • C++ vector拷贝使用总结

    万次阅读 多人点赞 2017-06-12 09:48:55
    vector list; list.push_back(1); list.push_back(2); 一、初始化构造时拷贝 vector tem(list);这种拷贝,相当于复制了一份数据,list中的数据不变。 二、assign vector temlist; temlist.assign(li
  • vectorint > v1(v2);//声明 1 vectorint > v1();v1.swap(v2);//将两个容器内的元素交换 需要构建临时对象,一个拷贝构造,两次赋值操作。 1 2 ...
1 2 3 4 5 ... 20
收藏数 1,140,223
精华内容 456,089
关键字:

vector