精华内容
下载资源
问答
  • c++ vector数组的使用

    万次阅读 2018-07-26 19:29:43
    1.vector数组是一个能存放任意数据类型(类,结构,普通变量类型等)动态数组! 2.和普通数组一样可以通过下标索引来进行访问! 3.与其它动态序列容器相比(deques, lists and forward_lists), vector在访问...

    介绍:

    首先我们要明白以下几点:

    1.vector数组是一个能存放任意数据类型(类,结构,普通变量类型等)的动态数组

    2.和普通数组一样可以通过下标索引来进行访问

    3.与其它动态序列容器相比(deques, lists and forward_lists), vector在访问元素的时候更加高效,在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作,效率更低。比起lists和forward_lists统一的迭代器和引用更好。

    4.vector动态数组可以通过数组名进行直接赋值!  vector<yang> c;   vector<yang> b;    b = c; 

    5.他的缺点:当新元素插入时候,这个数组需要被重新分配大小为了增加存储空间。其做法是,分配一个新的数组,然后将全部元素移到这个数组。就时间而言,这是一个相对代价高的任务,因为每当一个新的元素加入到容器的时候,vector并不会每次都重新分配大小。(比普通的数组具有更高的时间复杂度和空间复杂度

    vector的常规操作:

    vector的定义:

    复制代码

    #include<vector>//头文件一定要有
    
    using namespace std;//其所在的命名空间
    
    vector<int> vec;        //声明一个int型向量
    
    vector<int> vec1(4,1);                            //vec1的内容为1,1,1,1 
    vector<int> vec1{ 1, 2, 3, 4, 5, 6 };             //vec1内容1,2,3,4,5,6
    
    vector<int> vec(tmp);   //声明并用tmp向量初始化vec向量(也可以用vec=t,p)
    
    int arr[5] = {1, 2, 3, 4, 5};   
    vector<int> vec(arr, arr + 5);      //将arr数组的元素用于初始化vec向量
    //说明:当然不包括arr[4]元素,末尾指针都是指结束元素的下一个元素,
    //这个主要是为了和vec.end()指针统一。
    vector<int> vec(&arr[1], &arr[4]); //将arr[1]~arr[4]范围内的元素作为vec的初始值
    

    复制代码

     数组插入元素:

    1.vec.push_back(同类型量);作用是在vector的末尾插入新元素;

    2.insert()第一个参数为迭代器,作用为在迭代器前面插入新元素;

    3.assign(5,1)向vector中加入5个1,同时清除掉以前的元素。

    复制代码

      std::vector<int> vec1;  
      vec1.push_back(1);  
      vec1.push_back(2);  
    //vec1元素:1,2
      std::vector<int> vec2(vec1);  //将vec1赋值给vec2
      std::vector<int>::iterator it;  
      it=vec2.begain();  
      vec2.insert(it,5);  //在第一个元素前添加5
      it=vec2.begain();  //每当新插入一个元素时内存重新分配所以要重新为迭代器分配指针
      vec2.insert(it,2,6); 
      std::vector<int> vec3(vec2);  
      vec3.assign(2,5);  //清楚所有元素只留两个5

    复制代码

     

    删除元素: 

    1.pop_back()删除最后一个元素。

    2.erase()删除指定位置元素。(其中的参数要是指针变量,比如begain(),end(),以及迭代器值),例如vec.erase(vec.begin()+2);删除第3个元素

    3.clear()清除所有元素。

    4.empty()判断该数组是否为空

    遍历数组:

    1.front()访问第一个元素(第一个元素的值而不是地址!begin()相反)

    2.back()访问最后一个元素(最后一个元素的值而不是地址!end()相反)

    3.size()数组的元素个数

    复制代码

    vector<int> a;
    //像数组一样以下标访问 
    for(int i = 0; i < a.size(); i++)
    {
        cout << a[i];
    }
     
    //以迭代器访问
    vector<int>::iterator it;
    for(it=a.begin(); it!=a.end(); it++)
    {
        cout<<*it<<" " ;
    }

    复制代码

     

    翻转和排序的遍历:

    复制代码

    #include <algorithm>
    reverse(vec.begin(), vec.end())//将元素翻转,即逆序排列!
    
    #include <algorithm>
    sort(vec.begin(), vec.end()); //采用的是从小到大的排序
    //如果想从大到小排序,可以采用上面反转函数,也可以采用下面方法:
    bool Comp(const int& a, const int& b) {
        return a > b;
    }
    sort(vec.begin(), vec.end(), Comp);

    复制代码

    使用注意事项:

    迭代器中删除元素的操作时:

    删除元素:

    复制代码

    std::vector< int> Vec;
    std::vector< int>::iterator itVec;
    for( itVec = Vec.begin(); itVec != Vec.end(); )
    {
          if( WillDelete( *itVec) )
          {
              itVec = Vec.erase( itVec);
           }
          else
              itList++;
    }

    复制代码

         对vector、queue等,每次erase操作,函数会删除指定迭代器位置的元素,然后将后面的元素前移一位,erase返回指向被删除元素下一元素的迭代器。(其实,我认为,返回的还是指定的迭代器,只不过它现在指向了被删除元素的下一元素,如有不对,恳请大家指正!)

         对于erase操作,还有一种写法是:Vec.erase(itVec++)

        不过需要注意,这种写法对vector、deque等容器无效!

    上面两种写法,第一种对各种容器都有效,第二种写法只对map,list等容器有效。为了方便统一,还是建议采取第一种写法。

    增加元素:

    出于学习的目的,现在提出一个要求,如原有vector为{1,2,3,4,5},现在要在每个元素前加一个8,使vector变为{8,1,8,2,8,3,8,4,8,5}.用循环表示,代码如下:

    复制代码

    #include<iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> vec{ 1,2,3,4,5};
        auto iter = vec.begin();
        for (; iter != vec.end();)
        {
            iter = vec.insert(iter,8);
            iter++;
            iter++;
        }
        for (auto num : vec)
            cout << num << endl;
        return 0;
    }

    复制代码

    需要注意的是,insert会将指定对象插入指定迭代器之前的位置,并返回这个位置的迭代器,要想该迭代器指向之前的下一个元素,需要递增两次。

    如果需要在每个元素之后插入元素,该怎么操作?

    复制代码

    #include<iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> vec{ 1,2,3,4,5};
        auto iter = vec.begin();
        iter++;
        for (; iter != vec.end();)
        {
            iter = vec.insert(iter,8);
            iter++;
            iter++;
        }
        vec.insert(vec.end(),8);
        for (auto num : vec)
            cout << num << endl;
        return 0;
    }

    复制代码

    这里需要对iter首先自增一次,在循环最后,由于iter自加两次,已经和end()函数返回迭代器位置一致,所以需要再insert一次,才能在尾部再插入一个元素。

    展开全文
  • 1.vector数组的初始化 (1): vector ilist1; 默认初始化,vector为空, size为0,表明容器中没有元素,而且 capacity 也返回 0,意味着还没有分配内存空间。这种初始化方式适用于元素个数未知,需要在程序中动态添加...

    在C++中,vector是一个非常有用的“容器”,它能够存放各类型的数据,并且可以动态分配内存。下面介绍一下使用vector需注意的几点:

    1.vector数组的初始化
    (1): vector ilist1;

    默认初始化,vector为空, size为0,表明容器中没有元素,而且 capacity 也返回 0,意味着还没有分配内存空间。这种初始化方式适用于元素个数未知,需要在程序中动态添加的情况。
    

    (2): vector ilist = {1,2,3.0,4,5,6,7};
    这种初始化类似于普通数组的初始化形式
    ilist 初始化为列表中元素的拷贝,列表中元素必须与ilist的元素类型相容,本例中必须是与整数类型相容的类型,整形会直接拷贝,其他类型会进行类型转换

    (3): vector ilist(5);

    默认值初始化,ilist中将包含5个元素,每个元素进行缺省的值初始化,对于int,也就是被赋值为0,因此ilist被初始化为包含5个0。当程序运行初期元素大致数量可预知,而元素的值需要动态获取的时候,可采用这种初始化方式。

    (4):vector ilist(7,3);

    指定值初始化,ilist被初始化为包含7个值为3的int

    常见错误赋值方法

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

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

    double Distance(vector&a, vector&b) 其中的“&”一定不能少!!!
    下面是以vector作为返回值时的写法

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        int rob(TreeNode* root) {
            vector<int>res=dp(root);
            return max(res[0],res[1]);
        }
        vector<int> dp(TreeNode* root){
           if(root==NULL)
           return vector<int>{0,0};
            vector<int>left=dp(root->left);
            vector<int>right=dp(root->right);
            int rob=root->val+left[0]+right[0];
            int not_rob=max(left[0],left[1])+max(right[0],right[1]);
            return vector<int>{not_rob,rob};//注意此处not_rob与rob的位置
            //因为我们定义的是arr[0]是不抢,arr[1]代表抢,所以第一个元素必须是
            //not_rob,否则会得到错误的答案。
        }
    };
    

    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;
     
    }
    

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

    vector的优点:

    1.   可以使用下标访问个别的元素
      
    2.   迭代器可以按照不同的方式遍历容器
      
    3.   可以在容器的末尾增加或删除元素      
      

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

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

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

    二维数组初始化
    std::vector vec(10,90); //将10个一维动态数组初始为90
    std::vector<std::vector > vec(row,vector(col,0)); //初始化row * col二维动态数组,初始化值为0,其实就是每一行初始化为列数个0

    int size_row = vec.size(); //获取行数
    int size_col = vec[0].size(); //获取列数

    下面是leetcode上“二叉树的层次遍历”问题的代码,其中很好地运用了二维动态数组来解决问题,思路简洁明了。

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        vector<vector<int>> levelOrder(TreeNode* root) {
            vector<vector<int>>ans;
            pre(root,0,ans);
            return ans;
    
        }
        void pre(TreeNode *root,int depth,vector<vector<int>>&ans){
            if(!root) return;
            if(depth>=ans.size()){
                //二维数组每行存储一层的数据,到下一层遍历时,depth加一
                //所以当depth>=行数时,证明到了下一层的遍历,需要追加一行
                ans.push_back(vector<int>{});
                }
                ans[depth].push_back(root->val);
                pre(root->left,depth+1,ans);
                pre(root->right,depth+1,ans);
        }
    };
    

    而为数组追加行数时,直接用数组名.push_back(vector<>{}//注意此时的{}不能省去)而在某一行追加列数时,用数组名[行数].push_back();

    展开全文
  • vector是长度可变向量,可替代内置数组使用vector,必须包含头文件 实例 //vector的数组习惯用法 vector<int> array(10); for(int id = 0; id < 10; id++) { array[id] = id; } vector<int...

    标准库类型Vector(补充)

    特点

    表示对象的集合,其中所有对象的类型都相同,可以通过索引访问各个对象

    用法

    vector是长度可变的向量,可替代内置数组

    要使用vector,必须包含头文件

    实例

    //vector的数组习惯用法 
    	vector<int> array(10);
    	for(int id = 0; id < 10; id++)
    	{
    		array[id] = id;
    	}
    	vector<int> anotherarray;
    	anotherarray = array;
    	cout<<"size: "<<anotherarray.size()<<endl;
    	for(int id = 0; id<10; id++)
    	{
    		cout<<anotherarray[id]<<" ";
    	}
    

    结果:

    size: 10

    0 1 2 3 4 5 6 7 8 9

    //vector的STL使用用法 
    	vector<double> dv;
    	for(int id = 0; id<5; id++)
    	{
    		dv.push_back((id+1)/4.0);
    	}
    	cout<<"size: "<<dv.size()<<endl;
    	vector<double>::iterator it;		//迭代器iterator,好像是一个指针变量 
    	for(it = dv.begin(); it != dv.end(); it++)//dv.end()动态数组的最后一个元素的下一个位置
    	{
    		cout<<*it<<" ";
    	} 
    	for(int id =0; id<3; id++)
    	{
    		dv.pop_back();
    	}
    	cout<<"\nsize: "<<dv.size()<<endl;
    	for(it = dv.begin(); it<dv.end(); it++)
    	{
    		cout<<*it<<" ";
    	 } 
    

    结果:

    size: 5

    0.25 0.5 0.75 1 1.25

    size: 2

    0.25 0.5

    展开全文
  • vector 数组 简单使用

    2019-11-13 20:42:05
    vector是可以动态的开辟数组的形式。 以int 类型举例 一维数组: 1、固定存储 一维数组的定义: inta[10]; 数组初始化:memset(a,-1,sizeof(a));(ps:memset是按照字节赋值的,初始化的时候一般为-1,0,0x3...

    vector是可以动态的开辟数组的形式。 以int 类型举例

    一维数组:

       1、固定存储

                一维数组的定义:  int a[10];

                数组初始化:memset(a,-1,sizeof(a));(ps:memset是按照字节赋值的,初始化的时候一般为-1,0,0x3f。原因:https://blog.csdn.net/peterkang202/article/details/45770947

      2、动态存储

             一维数组义: vector<int> a();可以后续自动增加数组大小

             初始化:vector<int> a(5,3);表示初始值为3的5个数据的一维数组

    二维数组:

       1、固定存储

                  int a[105][105];

      2、动态存储

               vector<vector<int>> vec(10, vector<int>(8),20); //10行8列,全部初始化为20的二维整数数组

     

    struct 结合:

    
    struct DATA
    {
    	int x;
    	int y;
        int weight;
    }
    
    DATA data;
    vector<DATA> mapRoadNet(0);
    data.x=u;
    data.y=v;
    data.weight=rand()%100+1;
    mapRoadNet.push_back(data);
    vector<DATA>::iterator it;
    for(it=mapRoadNet.begin();it!=mapRoadNet.end();it++)
    {
      if( (it->weight) < Inf)
      {
          cout<<it->x<<"---"<<it->y<<endl;
      }
    }
    //vector除了iterator 还可以用数组的形式访问,如访问vector的第三个数据的x,可以写成
    
    mapRoadNet[2].x;

     

    展开全文
  • vector数组的初始化: vector month = { 1,2,3,4,5,6,7,8,9,10,11,12 } vector month = { 1,2,3,4,5,6,7,8,9,10,11,12 } vector< int > month { 12 } 像这样的声明会有歧义,究竟是0位置有一个元素12还是大小...
  • 1)vector数组是一个能存放任意数据类型(类,结构,普通变量类型等)动态数组! 2)和普通数组一样可以通过下标索引来进行访问 3)与其它动态序列容器相比(deques, lists and forward_lists),vector在...
  • C++--vector数组使用

    2021-01-05 11:40:21
    主要是记住一维和二维数组的定义以及区别,它们初始化,和添加删除元素是有点不太一样的。 一维数组 vector<int> arr; arr.size(); arr.begin(); arr.insert(); arr.push_back(); arr.end(); 二维数组 ...
  •  这里vector<int>v[10]是 vector数组。可以像定义数组指针那样去定义。 /* *********************************************** Author :guanjun Created Time :2017/3/18 13:32:52 File Name :33.cpp *******...
  • C++使用vector创建三维、四维、五维数组等高维数组的方法:实现功能为:创建三维数组a1[n][m][k]全部赋值为3创建四维数组a2[n][m][k][p]全部赋值为4创建五维数组a3[n][m][k][p][q]全部赋值为5并将数组里面的值进行...
  • #include  #include  using namespace std;   ... double average(const vector &arr)  {  double sum = 0;  for (unsigned i = 0; i  {  sum += arr[i];  }  return sum /
  • 清除“vector数组元素,但不清除内存 要注意清除之后一定要记得重新“装载数据”
  • (给CPP开发者加星标,提升C/C++技能)来源:Leehmwww.cnblogs.com/leehm/p/10929756.html1、初始化c++ 11以后新增了大括号{}初始化方式,需要注意与()区别,如:std::vector vecTest1(5); //初始化5个元素,每个都...
  • vector v; v.erase(v.begin()+1,v.begin()+2); 注意erase(m,n)删除第m到第n个元素,第n个不会被删除 CCCallFunc::create(this, callfunc_selector(testCallFunc::callback1)), CCCallFuncN::create(this, ...
  • 针对vector和队列分别使用了2个代码,当然思想是一样,但是操作起来有一点不太一样,其中vector不能使用pop_back,因为数组并没有delete,所以只能用遍历,但是...vector数组版: class Solution { public: b...
  • C++ vector数组用法记录

    2018-12-12 11:20:05
    name 其中type为变量类型,name为vector数组名称 注意:使用vector需要在头文件添加加 #include &lt;vector&gt; vector常用函数: push_back(elem):在数组最后添加数据 pop_back() :去掉数组最后一个...
  • Vector数组可以使用下标直接访问

    千次阅读 2004-10-18 16:41:00
    Vector可以使用[]直接访问,里面填入从0到n-1索引即可
  • 使用JNI的过程中,在Java端使用C++程序中的回调函数,对程序来说很方便,最近在做图形识别的过程中遇到了数组的转换方面的问题,后来仔细想了一下,在网上简单看了点资料,发现在JNI层对vector数组转换,最后在回调...
  • 程序首先构建二维vector数组viA,然后对其进行打印,之后,按照不同方式对其进行排序。 程序如下: #include <iostream> #include <vector> #include <stdlib.h> #include <algorithm> ...
  • 使用Dev-C++查看vector数组变量值

    千次阅读 2017-03-03 12:28:50
    可以通过调试的时候添加查看:比如说有一个长度为3的vector v,如果想要查看v...如果想要查看整个数组的值,就可以写*(&v[0])@3 @后面的数字表示想要查看的长度,这里vector的长度是3所以可以写3就能看到所有的值~
  • vector作为数组的替代品,是相当好用的。数组有下标定位,Vector同样有定位。 1。iterator迭代器 begin(): 获取vector第一个元素的迭代器。 end():获取最后一个元素的下一个位置,就是空位置。 优点:end()...
  • 头文件 class Vector_test { public: Vector_test(); double rand(); };...Vector_test::Vector_test() ... //数组使用必须初始化,不然使用的时候会报错 vector<double> arrayTest(10); qDebug() &l

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,114
精华内容 4,045
关键字:

vector数组的使用