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的详细用法

    千次阅读 多人点赞 2019-10-09 08:18:16
    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操作

    万次阅读 多人点赞 2019-05-28 11:24:15
    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:40
    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

    展开全文
  • C++ 中vector的使用方法

    万次阅读 多人点赞 2016-02-01 10:21:20
    C++ 中vector的使用方法(纯干货!)

    在c++中,vector是一个十分有用的容器

    作用:它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据。

    vector在C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库

    特别注意:

    使用vector需要注意以下几点:

    1、如果你要表示的向量长度较长(需要为向量内部保存很多数),容易导致内存泄漏,而且效率会很低;

    2、Vector作为函数的参数或者返回值时,需要注意它的写法:

       double Distance(vector<int>&a, vector<int>&b) 其中的“&”绝对不能少!!!


    实例:vector<int>test;

    //建立一个vector,int为数组元素的数据类型,test为动态数组名

    简单的使用方法如下:

    vector<int>test;//建立一个vector

    test.push_back(1);

    test.push_back(2);//把1和2压入vector,这样test[0]就是1,test[1]就是2

     

    自己见到的实例:

    vector<vector<Point2f> > points; //定义一个二维数组

    points[0].size();  //指第一行的列数

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

    特别提示:这里有begin()与end()函数、front()与back()的差别

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

     

    输出Vector的中的元素   

    vector<float> vecClass; 

    int nSize = vecClass.size();   

     //打印vecClass,方法一:  

    for(int i=0;i<nSize;i++)  
    {  
       cout<<vecClass[i]<<"     ";  
    }  
       cout<<endl; 

    需要注意的是:以方法一进行输出时,数组的下表必须保证是整数。

     //打印vecClass,方法二:     

    for(int i=0;i<nSize;i++)  
    {  
       cout<<vecClass.at(i)<<"     ";  
    }  
       cout<<endl;  

    //打印vecClass,方法三:输出某一指定的数值时不方便

    for(vector<float>::iterator it = vecClass.begin();it!=vecClass.end();it++)  
    {  
        cout<<*it<<"   ";  
    }  
        cout<<endl;  

    二维数组的使用:

    #include "stdafx.h"
    #include <cv.h>
    #include <vector> 
    #include <iostream> 
    using namespace std;
    int main()
    {
    	using namespace std;
    	int out[3][2] = { 1, 2, 
    			 3, 4,
    			5, 6 };
    	vector <int*> v1;
    
    	v1.push_back(out[0]);
    	v1.push_back(out[1]);
    	v1.push_back(out[2]);
    
    	cout << v1[0][0] << endl;//1
    	cout << v1[0][1] << endl;//2
    	cout << v1[1][0] << endl;//3
    	cout << v1[1][1] << endl;//4
    	cout << v1[2][0] << endl;//5
    	cout << v1[2][1] << endl;//6
    
    	return 0;
    }


    vector中insert()的用法详解:http://blog.csdn.net/duan19920101/article/details/51557854

     


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

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

    2020-08-17 14:00:13
    vector: vector的数据安排以及操作方式与array非常类似。两者唯一的差别就是在于空间的运用灵活性,array是静态空间,一旦分配了就是固定的,无法改变其大小。需要用户重新申请更大的空间,移动数据,释放原来的...
  • vector内部的实现1

    2019-09-24 17:18:24
    vector的内部方法 1 #include<vector> 2 using std::vector; 3 //写一个动态内存 4 5 class CA{ 6 int a; 7 public: 8 CA(int i){ i = a; } 9 CA(); 10 }; 11 template <clas...
  • Qvector&Vector

    2019-11-08 10:18:32
    QVector<int> temp; QVector<int> tpem2; for (int k = 0; k < Number_cont; k++) { temp.push_back(k); } for (int i = 0; i < temp.size(); i++) { tpem2 <......
  • vector部分知识总结

    2020-11-18 13:48:10
    1:#include :
  • C++ Vector 模板类

    2020-11-23 13:22:11
    Vector.h #pragma once #include <iostream> using namespace std; template <typename T> class Vector { //template <typename T> friend ostream &operator<<<T>(ostream ...
  • vector详解

    千次阅读 2017-08-14 23:06:41
    引言emmm…这篇博客写作的缘由其实就是我在日常使用vector的时候发现对vector并不怎么了解所以决定写这篇博客的。 写这篇博客,我参考了vector - C++ Reference中的内容,及侯捷先生的《STL源码剖析》一书,所实验...
  • C++vector的使用总结及常用vector操作

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

    千次阅读 2018-03-29 14:45:10
    原文地址:https://blog.csdn.net/lsn946803746/article/details/52174425Vectors vectorC++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个...
  • C++ vector的用法(整理)

    万次阅读 多人点赞 2018-08-31 14:36:03
    C++ vector的用法(整理) vector 是向量类型,它可以容纳许多类型的数据,如若干个整数,所以称其为容器。vectorC++ STL的一个重要成员,使用它时需要包含头文件: #include&lt;vector&gt;; 一、...
  • c++ vector 释放内存

    千次阅读 2013-11-28 10:12:27
    关于Vector中存放指针的问题,在进行清空的时候比较安全的一种做法是:  std::vector ClassNameVec;  ...push_back(new ClassName());  std::vector::iterator ClassNameIt = ClassNameVec.begin();  for(;...
  • C++ Vector 使用说明

    万次阅读 多人点赞 2018-12-20 16:53:09
     向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的...
  • C++ vector的用法

    万次阅读 多人点赞 2019-06-19 16:57:48
    vectorC++ STL的一个重要成员,使用它时需要包含头文件: #include<vector>; 一、vector 的初始化:可以有五种方式,举例说明如下: (1) vector<int> a(10); //定义了10个整型元素的向量(尖...
  • c++vector的用法详解

    千次阅读 多人点赞 2018-09-05 13:32:17
    c++vector的用法详解 2011年12月01日 21:25:06 阅读数:414421 标签: vectorc++stringinsert测试数据结构更多 个人分类: c语言  vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态...
  • vector insert用法 C++

    万次阅读 2017-08-29 13:02:10
    #include #include using namespace std; int main() ... vector v(3); v[0]=2; //v[0]是第0个元素 v[1]=7; v[2]=9; v.insert(v.begin(),8);//在最前面插入新元素。 v.insert(v.begin()+
  • C++(笔记)容器(vector)作为函数参数如何传参

    万次阅读 多人点赞 2017-05-17 17:51:54
    void 函数名( vector< int> obj ); void 函数名( vector* pobj ); void 函数名( const vector* pobj ); // 在函数内不能改变 pobj 指向的对象 ,//调用时不会调用拷贝构造函数 void 函数名( vector< int>& obj ...
  • vector其中一个特点:内存空间只会增长,不会减小,援引C++ Primer:为了支持快速的随机访问,vector容器的元素以连续方式存放,每一个元素都紧挨着前一个元素存储。设想一下,当vector添加一个元素时,为了满足连续...
  • C++vector使用详细说明

    万次阅读 多人点赞 2019-03-18 22:06:44
    C++vector使用详细说明 转自:http://blog.chinaunix.net/uid-26000296-id-3785610.html    http://www.cnblogs.com/mr-wid/archive/2013/01/22/2871105.html    ...
  • C++:vector + vector二维数组的初始化

    千次阅读 2019-10-09 21:03:24
    1. vector二维数组初始化方法: 2.示例代码 unsigned int rows = costMatrix.rows(); unsigned int cols = costMatrix.cols(); vector< vector<double> > costFunc(rows,vector<double>...
  • C++ Vector (动态数组)

    千次阅读 2020-01-09 20:25:11
    简介 向量(Vector)是一个封装了动态大小数组的顺序容器。 向量是一个能够存放任意类型的动态数组。...C++Vector 的使用 头文件 #include <vector> 需要使用 std 命名空间 using namespace std; ...
  • C++ - Vector 计算 均值(mean) 和 方差(variance)

    万次阅读 多人点赞 2014-04-28 10:09:17
    Vector 计算 均值(mean) 和 方差(variance) 本文地址:http://blog.csdn.net/caroline_wendy/article/details/24623187 vector<>类型的数组, 计算均值和方差的最简方法. 代码: double sum = std:...
  • C++Vector用法

    万次阅读 2013-11-25 09:14:34
    C++Vector用法   C++内置的数组支持容器的机制,但是它不支持容器抽象的语义。要解决此问题我们自己实现这样的类。在标准C++中,用容器向量(vector)实现。容器向量也是一个类模板。 标准库vector类型使用...
  • C++vector入门

    千次阅读 多人点赞 2019-07-03 20:07:16
    文章目录一、头文件 一、头文件 在std中,所以只用打 using namespace std;
  • C++ STL vector assign用法

    2015-10-03 01:12:09
    原帖地址:... vector::assign //用来构造一个vector的函数,类似于copy函数 void assign( size_type _Count, const Type& _Val); //_Count指要构造的vector成员的个数, 
  • C++vector初始化

    2019-09-29 19:08:18
    一维vector 大小:std::vector v(9) 大小和初值:std::vector v(9, 0),大小为9,初值均为0。 大小和不同的初值: int x[] = {1, 2, 3}; std::vector<int> v(x, x + sizeof(x) / sizeof(x[0])); // or ...
  • 【C/C++Vector的创建与初始化方法

    万次阅读 2019-06-14 16:21:01
    vector<int> list1; 默认初始化,vector 为空, size 为0。容器中没有元素,而且 capacity 也返回 0,意味着还没有分配内存空间。这种初始化方式适用于元素个数未知,需要在程序中动态添加的情况。 方法二...

空空如也

1 2 3 4 5 ... 20
收藏数 1,288,236
精华内容 515,294
关键字:

vector