精华内容
下载资源
问答
  • vector push_back()方法解析

    千次阅读 2019-12-20 10:03:43
    如果需要一个更大或者更小的空间,需要重新设置数组的大小,这样才能重新配置新空间,并将元素从旧地址搬到新地址,再释放新的空间系统。而vector是动态空间,随着新元素的加入,内部机制会自动扩充空间容纳新元素...

    STL
    vector和array的区别在于,数组为静态空间,一旦配置了就不能改变;如果需要一个更大或者更小的空间,需要重新设置数组的大小,这样才能重新配置新空间,并将元素从旧地址搬到新地址,再释放新的空间给系统。而vector是动态空间,随着新元素的加入,内部机制会自动扩充空间容纳新元素。
    vector维护的是一块连续的线性空间。数据结构比较简单,通过两个迭代器start和finish分别指向配置的空间中目前被使用的头和尾,迭代器end_of_storage指向整块空间的尾。

    template<class T,class Alloc=alloc>
    class vector{
    
        
        protected:
            typedef simple_alloc<value_type,Alloc> data_allocator;
            iterator start;
            iterator finish;
            iterator end_of_storge;
        ...
    }
    

    vector提供了许多构造函数,通常采用

         vector(size_type n,const T& value){fill_initialize(n,value);}
    

    来为vector赋大小和初值。
    此时通过fill_initialize函数配置了n个空间,然后填充初值。
    以下结合push_back来查看vector内存空间的变化:

    int main(){
        vector<string> ex(10,"34");
        vector<string>::iterator iter;
        for(iter=ex.begin();iter!=ex.end();iter++)
            cout<<*iter;    
    
        cout<<"size"<<ex.size()<<"\ncapacity"<<ex.capacity();
        ex.push_back("1");
        cout<<"size"<<ex.size()<<"\ncapacity"<<ex.capacity();
        ex.push_back("3");
        cout<<"size"<<ex.size()<<"\ncapacity"<<ex.capacity();
        ex.pop_back();
        cout<<"size"<<ex.size()<<"\ncapacity"<<ex.capacity();
        ex.clear();
        cout<<"size"<<ex.size()<<"\ncapacity"<<ex.capacity();       
    }
    

    在这里插入图片描述
    如图可见,首先构造了大小为10的vectror,此时配置了10个空间的大小,然后为每个空间配置了初值。当使用push_back向vector尾端添加新元素时,此时原空间不够用了。则以原先两倍的大小配置一块新空间,然后将原先的内容拷贝过来,之后在原内容尾端添加新的元素,释放原始空间。当我们对这部分空间的值clear之后,发现容量的大小仍然为之前扩容后的20个。
    除此之外,当从原空间将元素拷贝到新空间之后,引起空间的重新配置,此时指向原先vector的迭代器就全部失效了。

    int main()
    {
        vector<int> ex(10,9);
        vector<int>::iterator iter1=ex.begin();
        cout<<*iter1<<"\n";
        ex.push_back(1);
        cout<<*iter1<<"\n";
        vector<int>::iterator iter2=ex.begin();
        cout<<*iter2<<"\n";
    }
    

    在这里插入图片描述
    如图可见,当构造vector之后,大小容量均为10,当push_back新的元素时,空间重新配置了,此时先前的迭代器仍然指向原来的地址空间。

    展开全文
  • 补充内容 ...v.resize()该函数的使用方法是:有数据大小之后重新设置大小,多退少补 v.reserve :据说的是容量,能够存储的最多的长度, size是长度 capacity 是容量 push_back()还有与之相对的是pop_back

    补充内容

    1. begin, end,返回的是迭代器的位置,并不是指针
    2. data()函数可以返回的是第一个元素指针的位置
    3. end(),返回的最后一个元素后面一个位置,也就是元素后端的占位符
    4. rend(),从后往前的第一个元素的位置
    5. resize(),重新设置大小,添加元素之后
    6. v.resize()该函数的使用方法是:有数据大小之后重新设置大小,多退少补
    7. v.reserve :据说给的是容量,能够存储的最多的长度, size是长度 capacity 是容量
    8. 还支持front 和 back()函数 ,
    9. push_back()还有与之相对的是pop_back()
    10. 迭代器的使用时是 迭代器::iterator 迭代器名称
    11. 迭代器只有 ++ 和 *(解运算符)总之非常好用
    12. 看其中代码部分,需要加强使用规则!
    #include <iostream>
    #include <vector>
    #include <deque>
    using namespace std;
    
    int main()
    {
        int a[10] = {1,3,5,9,7};
        vector <int> v;
        v.reserve(100);
    
        v.insert(v.begin(),a,a+3);
        int *p = v.data();
        v.push_back(4);
        cout << (*p) << " " << *(p+3) <<endl;
        // v.erase(.begin(),v.begin()+2);
    
        cout << "front: "<< v.front() << " " << v.back() <<endl;
        v.pop_back(); 
        vector<int>::iterator it = v.begin();
    
        //只有三个元素,但是v.end()指向的最后元素的后一个位置
        int k = distance(v.begin(),v.end());
        cout <<"dist: " << k << endl;
        for(;it != v.end();it++)
            cout <<*it <<" ";
        cout <<endl;
        v.resize(20);
        cout <<v.capacity() << ' ' << v.size() << endl;
        // v.shrink_to_fit();
        cout << v.capacity() << endl;
        cout << v.max_size() << endl;
        return 0;
    }
    
    展开全文
  • #include //声明C标准库函数bsearch()和qsort(),进行搜索和排序的...#include //定义vector序列模板,这是一个大小可以重新设置的数组类型,比普通数组更安全、更灵活 #include //支持迭代器的头文件 #include
    #include <cstdlib>  //声明C标准库函数bsearch()和qsort(),进行搜索和排序的头文件
    #include <iostream>  //支持流输入/输出的头文件
    #include <fstream>  //支持文件流输入/输出的头文件
    #include <vector>  //定义vector序列模板,这是一个大小可以重新设置的数组类型,比普通数组更安全、更灵活
    #include <iterator>  //支持迭代器的头文件
    #include <list>  //定义list序列模板的头文件,这是一个序列的链表,常常在任意位置插入和删除元素
    #include <map>  //map是一个关联容器类型,允许根据键值是唯一的,且按照升序存储。
    #include <sstream>  //支持字符串的流输入输出
    #include <queue>  //为队列(先进先出)数据结构定义序列适配器
      
    #ifndef _ACDLL_H_  
    #define _ACDLL_H_  
      
    using namespace std;  
    char const BASE='a';  
    char const INFINIT=-1;  
      
     
    // data structure  
     
      
      
    struct match_result        //声明了一个匹配结果的结构
    {  
           int count;  //定义一个int型变量count
           list<int> offset;  //定义了一个
    };  
      
    // Node - this structure stands for each stat in side the stat machine  
    class Node
    {  
      
          public:  
          Node(int _stat, Node * _parent, char _c)
     {  
      
                   parent=_parent;  
      
                   c=_c;  
                   is_out_node=false;  
                   stat=_stat;  
      
                   child=NULL;  
                   siblings=NULL;  
                   Fail=NULL;  
          }  
      
          ~Node()
     {  
            list<string *>::iterator it= out_str.begin();  
            while(it != out_str.end())

    delete *it;
        ;
    }  
          }  
      
          Node * get_child()
     {  
              return child;  
          }  
      
          void set_child(Node * node)
     {  
               child=node;  
          }  
          Node * get_sib()
     {  
              return siblings;  
          }  
          Node * get_parent()
     {  
              return parent;  
          }  
          void set_sib(Node * node)
     {  
               siblings=node;  
          }  
          bool get_is_out_node()
     {  
               return is_out_node;  
          }  
          void set_is_out_node()
     {  
               is_out_node=true;  
          }  
          char get_c()
     {  
               return c;  
          }  
          int get_stat()
     {  
               return stat;  
          }  
          void set_out_put(const string * str)
     {  
               out_str.push_back(new string(str->data()));  
          }  
          void show_out_put()
     {  
               list<string *>::iterator it= out_str.begin();  
               while(it != out_str.end())
      {  
                  cout<<"stat "<<stat<<" is output node of ["<<(*it)->data()<<"]"<<endl;  
                  ++it;  
      }  
          }  
      
          list<string *> * get_out_put()
     {  
              return &out_str;  
          }  
      
          void set_Fail(Node * node)
     {  
               //if(node)cout<<"set "<<stat<<" Fail with "<<node->get_stat()<<endl;  
               Fail=node;  
          }  
          Node * get_Fail()
     {  
               return Fail;  
          }  
      
          Node * get_child_with_c(char _c)
     {  
               //cout<<_c<<" stat "<<stat<<endl;;  
               Node * ret=NULL;  
               //if(stat==0) return this;  
      
               if(child)
      {  
                   ret=child;  
                   //cout<<"xx"<<endl;  
                   while(ret)
      {  
                      // cout<<_c<<"  "<<ret->get_c()<<endl;  
                       if(ret->get_c()==_c)
      {
      return ret;
      }  
                       ret=ret->get_sib();  
                   }  
               }  
               if(stat==0)
      {
      return this;
      }  
               return ret;  
          }  
      
          private:  
          /* basic data */  
          Node * child;  
          Node * parent;  
          Node * siblings; //used for goto also?  
          int stat;  
          char c;  
      
          /* ac search data */  
          //Node * goto;  
          Node * Fail;  
          bool is_out_node;  
          list<string *> out_str;  
    };  
      
      
    // Tree  
    class Tree
    {  
          public:  
          Tree(Node * _root){root=_root;max_stat=0;}  
          ~Tree()
     {  
               Node * tmp=NULL;  
               queue_list.push_back(root);  
               while(!queue_list.empty())
      {  
                    tmp=queue_list.front();  
      
      
                    Node * child = tmp->get_child();  
                    Node * sib=NULL;  
                    if(child)
    {  
                       queue_list.push_back(child);  
                       sib=child->get_sib();  
    }  
                     )
    {  
                       queue_list.push_back(sib);  
                       sib=sib->get_sib();  
    }  
      
      
                       queue_list.pop_front();  
                       delete tmp;  
        } 

    }  
      
          void build_tree(vector<string> pattern)
     {  
              vector<string>::iterator iter=pattern.begin();  
              while(iter != pattern.end())
     {  
                  int index=0;  
                  _build_tree(&*iter,index,root); //pass down as string pointer till last step to create a string job to store in list  
                  iter++;  
              }  
          }  
      
          void _build_tree(const string * str, int index, Node * node)
     {  
      
               char c=str->at(index);  
               ++index;  
               Node *child = node->get_child();  
      
               while(child)
      {  
                   if(c!=child->get_c()) 
      {  
                       if(child->get_sib())
      {  
                           child=child->get_sib();  
                           continue;  
                       }
      else
      { 
      break;
      }  
                   }
      else
      {  
                         if(index<str->length())
    {  
                             _build_tree(str,index,child);  
                             return;  
                         }  
                         else
    {
    child->set_is_out_node();
    child->set_out_put(str);
    return;
    }  
                   }  
               }  
      
               Node * newnode = build_new_node(node,c);  
               if(child)
      {
      child->set_sib(newnode);
      }  
               else
      {
      node->set_child(newnode);
      }  
      
               if(index<str->length())
      {
      _build_tree(str,index,newnode);
      return;
      }  
               else
      {  
                    newnode->set_is_out_node();  
                    newnode->set_out_put(str);  
                    return;  
               }  
          }  
      
          Node * build_new_node(Node * node, char c)
     {  
               inc_max_stat();  
               Node * newnode= new Node(get_max_stat(),node,c);  
               return newnode;  
          }  
          void inc_max_stat()
     {  
               ++ max_stat;  
          }  
          int get_max_stat()
     {  
               return max_stat;  
          }  
      
          void show(Node *node)
     {  
              if(!node) 
     {
     return;
     }  
              Node * child = node->get_child();  
              if(child)
     {  
                  while(child)
     {  
                      cout<<"stat "<<node->get_stat()<<" will transfer to stat "<<child->get_stat()<<" via input of "<<child->get_c()<<endl;  
                      if(child->get_is_out_node()){child->show_out_put();}  
                      show(child);  
                      child=child->get_sib();  
                  }  
              }  
          }  
      
         // if using array, then to sc attered max_stat/(max_stat*sizeof(char set))  
         // if using link list, should take more cpu power to to search  
         // how about using hash(stat,char) and map(hash,stat)  
         // tradeoff between time and space  
          void build_Goto(){}  
      
          void calc_F(Node * node)
     {  
      
              Node * parent=node->get_parent();  
              Node * Fail_node = parent->get_Fail();  
              char c=node->get_c();  
              //cout<<"calc stat "<<node->get_stat()<<" with "<<c<<" and Fail node "<<Fail_node->get_stat()<<endl;  
              //cout<<"Fail_node->get_child_with_c(c) = "<<Fail_node->get_child_with_c(c)<<endl;  
              Node * Fail_child=NULL;  
              while(!(Fail_child=Fail_node->get_child_with_c(c)))
     {  
                  //cout<<"in loop with "<<node->get_stat()<<endl;  
                  Fail_node=Fail_node->get_Fail();  
                  //Fail_node=Fail_node->get_child_with_c(c);  
              }  
      
              node->set_Fail(Fail_child);  
              if(Fail_child->get_is_out_node())
     {  
                  list<string *> * _out_str=Fail_child->get_out_put();  
                  list<string *>::iterator it= _out_str->begin();  
                  while(it != _out_str->end())
     {  
                      node->set_out_put(*it);  
                      ++it;  
                  }  
                  //node->show_out_put();  
              }  
          }  
      
      
      
          void _build_Fail(Node * node)
     {  
              //cout<<"chacking stat "<<node->get_stat()<<endl;  
               Node * child = node->get_child();  
               Node * sib=NULL;  
               if(child)
      {  
                   queue_list.push_back(child);  
                   sib=child->get_sib();  
               }  
               while(sib)
      {  
                   queue_list.push_back(sib);  
                   sib=sib->get_sib();  
               }  
      
               if(node->get_stat()==0)
      {
      node->set_Fail(NULL);
      return;
      }  
               if(node->get_parent()->get_stat()==0)
      {
      node->set_Fail(node->get_parent());
      return;
      }  
      
               calc_F(node);  
          }  
      
          void build_Fail()
     {  
      
               queue_list.push_back(root);  
               while(!queue_list.empty())
      {  
                   _build_Fail(*queue_list.begin());  
                   queue_list.pop_front();  
               }  
          }  
      
      
          void match(const char * text)
     {  
              cout<<"match \""<<text<<"\""<<endl;  
              const char * ptr=text;  
              Node * node=root;  
              int offset=0;  
              while(*ptr)
     {  
                  //cout<<"deal with "<<*ptr<<" in stat "<<node->get_stat()<<endl;  
                  Node * _node=node->get_child_with_c(*ptr);  
                  if(_node)
     {  
                      node=_node;  
                      if(node->get_is_out_node())
     {  
                          //cout<<node->get_stat()<<endl;;  
                          list<string *> * _out_str=node->get_out_put();  
                          list<string *>::iterator it= _out_str->begin();  
                          while(it != _out_str->end())
     {  
                               //cout<<(*it)->c_str()<<endl;  
                               update_match_report(**it,offsett-((*it)->length())+1);  
                               ++it;  
                          }  
                      }  
      
                      ++ptr;  
                      ++offset; // cout<<ptr<<" "<<offset<<endl;;  
                  
     }
     else
     {  
                        //cout<<"get fail"<<endl;  
                      node=node->get_Fail();  
                  }  
      
              }  
          }  
      
          void add_match_report(string s)
     {  
              match_result mr;
     mr.count=0;  
              match_report.insert(map<string,match_result>::value_type(s,mr));  
          }  
      
          void update_match_report(string s,int _offset)
     {  
               match_report[s].count++;  
               match_report[s].offset.push_back(_offset);  
          }  
      
          void show_match_report()
     {  
               cout<<"================ match summary ================"<<endl;  
               cout<<"KEY\tCOUNT\tOFFSET"<<endl;  
              map<string,match_result>::iterator it= match_report.begin();  
              while(it != match_report.end())
     {  
                  cout<<"["<<it->first<<"]\t"<<it->second.count<<"\t";  
                  list<int>::iterator it1=it->second.offset.begin();  
                  while(it1 != it->second.offset.end())
     {  
                      cout<<*it1<<"\t";  
                      ++it1;  
                  }  
                  cout<<endl;  
                  ++it;  
              }  
          }  
      
          private:  
          Node * root;  
          list <Node *> queue_list;  
          //int ** Goto;  
          //int * Fail;  
          int max_stat;  
      
          map<string,match_result> match_report;  
    };  
      
      
    void usage()
    {  
         cout<<"usgae: app path_to_pattern_file path_to_text_file"<<endl;  
    }  
      
    #endif  
    展开全文
  • 位图

    2017-05-15 09:42:29
    C++代码实现#pragma once #include #include <vector> using namespace std;class BitMap { public: BitMap(size_t range) //定位图所能表示的 范围 { _bitmap.resize(range / 32 + 1); //设置大小

    C++代码实现

    #pragma once
    #include <iostream>
    #include <vector>
    using namespace std;
    
    class BitMap
    {
    public:
        BitMap(size_t range)   //给定位图所能表示的 范围
        {
            _bitmap.resize(range / 32 + 1);  //设置大小
        }
    
        void Set(size_t num)  //置 1
        {
            size_t index = num / 32;        //所在下标
            size_t pos = num % 32;          //所在位置
            _bitmap[index] |= (1 << pos);   
        }
    
        void Reset(size_t num)  //置 0 
        {
            size_t index = num / 32;
            size_t pos = num % 32;
            _bitmap[index] &= (~(1 << pos));
        }
    
        bool Test(size_t num)  //返回状态位
        {
            size_t index = num / 32;
            size_t pos = num % 32;
            return _bitmap[index] & (1 << pos);
        }
    
    protected:
        vector<size_t> _bitmap;
    };
    
    void TestBitMap()
    {
        BitMap bm(1000);
        bm.Set(1);
        bm.Reset(1);
        bm.Set(2);
        bm.Set(3);
        bm.Set(12);
        cout<<bm.Test(1)<<endl;
        cout<<bm.Test(2)<<endl;
    }
    展开全文
  • ITween插件

    2019-02-25 11:07:29
    这东西,暂时没搞懂怎么用,反正效果就是一个矩形,在出的值之间不停的变换位置和大小 16. 旋转(Rotate**) 根据移动(Move**)的函数推理一下就懂了,相信你的能力 RotateAdd(GameObject target, Vector3...
  • C++ Bitset (位集合) ...bitset类模板支持有效的的固定大小设置操作,vector模板规范支持动态大小的位字符串。 函数列表: Constructors 创建新bitsets  Operators 比较和赋值bitsets  any() 如果有任何一
  • 1、java数据结构包括一下几种接口和类枚举、位集合、向量、栈、字典、哈希表、属性、集合框架(java2中)2、数据结构各项定义枚举(Enumeration)接口...可以单独设置和清除的位和标志向量(Vector)对象的元素能通过索引访问...
  • 设置一个vector<vector<int>> v,第二维大小为26,代表的一个字符串中各个字母出现的次数。 对于每个新加入的str,遍历v,看是否存在已经满足的映射,如果没有,就在v里面建立新的映射。如果有,找到v里面对应的位置...
  • 一般来说,addForce()方法慢慢的改变物体的运动状态,velocity属性适合瞬间的物体设置一个速度来改变物体的运动状态(例如抛出物体)。 方法: addForce () 方法 public function addForce(f:Vector):void 粒子...
  • 该类在处理一组布尔值的时候非常有用,你只需要每个值赋值一"位",然后对位进行适当的设置或清除,就可以对布尔值进行操作了。 一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随...
  • //设置单选按钮大小和位置并添加到jpbr面板里同时添加到bg单选按钮组里 jrbxm.setBounds(5,3,50,26); jrbxm.addItemListener(this);//为单选按钮注册ItemEvent事件监听器 bg.add(jrbxm); jpbr.add...
  • 规定栈的大小,按照1~n的顺序入栈,随机出栈,出数列看是否可以通过出栈获得 注意点 在取用栈的top元素前需要判断栈是否为空 我的解题过程 思路 把需要判断的数列放入vector数组中,设置pos指向要从栈中找到的...
  • 多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值父类类型的指针。多...
  •   使用C++Vector进行写,先将所数据进行顺序排序,设置f等于第一个数字,s等于第二个数字,如果连续的数字相等,即f = s,则f和s往后推三个数字,如果数字不相等,那么第一个数字就是这个数组当中出现一次的数字...
  • leetcode 每日一题5.5

    2021-05-05 22:45:47
    你一个整数数组 nums ,你可以对它进行一些操作。 每次操作中,选择任意一个 nums[i] ,删除它并获得 nums[i] 的点数。之后,你必须删除每个等于 nums[i] - 1 或 nums[i] + 1 的元素。 开始你拥有 0 个点数。返回...
  • //设置它的大小 BOOL bMore = ::Module32First(hProcessSnap, &pe32); //取进程第一个模块 while (bMore) { sPm.push_back(pe32); //将模块信息加入迭代器 bMore = ::...
  • 顺便说一下设置栈保留大小也已经试过了,将栈保留大小设置为16000000也无效。 以下是本人代码: ``` // ConvexHull.cpp : Defines the entry point for the console application. // #include "stdafx...
  • HumanMotionTrack 全

    2010-12-09 11:30:55
    // 如果对象的大小小于0,则退出 t3DObject *pObject = &g_3DModel[j0].pObject[l];// 获得当前显示的对象 for(int j = 0; j < pObject->numOfFaces; j++) // 遍历所有的面 { for(int tex = 0; tex ; tex++) /...
  • txt文档阅读器

    2015-06-24 10:09:09
    //设置字体大小 mPaint.setColor(m_textColor);//设置颜色 mVisibleWidth = mWidth - marginWidth * 2; mVisibleHeight = mHeight - marginHeight * 2;//绘制的内容宽和高 mLineCount = (int) ...
  • #include #include ... //出这 5 个文件的文件分配表 cout 文件分配表中:" ; /* cout 的索引块为: " (FAT, fileA.name) ; cout 的索引块为: " (FAT, fileB.name) ; cout 的索引块为:...
  • # 设置词语上下文窗口大小 context = 4 model = Word2Vec(wordCut, workers=num_workers,vector_size=num_featrues, min_count=min_word_count,window=context) # 强制单位归一化 model....
  • //设置窗体大小 this.setSize(400, 654); //设置窗口居中显示 //this.setLocationRelativeTo(null); this.setLocation(150, 50); //设置任务栏图标 this.setIconImage(new ImageIcon("image/icon.jpg")....
  • 1.2.7 ─出关于网页的更多 信息 33 1.2.8 ─结束网页的头 35 1.2.9 ─建立网页的体 35 1.2.10 设置网页颜色 41 1.2.11 在网页中添加文本 45 1.2.12 基本的文本格式 46 1.2.13 <!-->─注释及服务器端的内容 47 ...
  • 目前思路是这样:在菜单上选择要画的图形,这时会choices赋一个值,代表要画的图形。 在鼠标点下的时候记录初始坐标。 鼠标抬起时记录终止坐标,并添加一个图形对象到保存的Vector中,再进行重绘。 ``` import ...
  • surfer 9.11汉化版.part2

    热门讨论 2011-03-23 08:44:20
    ----其中Angle,Length是位于X,Y,Z上之向量角度及大小.做法同c. 11.如何画Surfer的Breaklines and Faults? --可以 Grid -> Advanced options -> Breaklines and Faults (.bln文件要含Z值) 12.可以在Surfer上做程序...
  • ----其中Angle,Length是位于X,Y,Z上之向量角度及大小.做法同c. 11.如何画Surfer的Breaklines and Faults? --可以 Grid -> Advanced options -> Breaklines and Faults (.bln文件要含Z值) 12.可以在Surfer上做程序...
  • surfer 9.11 汉化.part1

    热门讨论 2011-03-23 08:46:07
    ----其中Angle,Length是位于X,Y,Z上之向量角度及大小.做法同c. 11.如何画Surfer的Breaklines and Faults? --可以 Grid -> Advanced options -> Breaklines and Faults (.bln文件要含Z值) 12.可以在Surfer上做程序...
  • surfer9.11汉化.part3

    热门讨论 2011-03-23 08:47:20
    ----其中Angle,Length是位于X,Y,Z上之向量角度及大小.做法同c. 11.如何画Surfer的Breaklines and Faults? --可以 Grid -> Advanced options -> Breaklines and Faults (.bln文件要含Z值) 12.可以在Surfer上做程序...

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

给vector设置大小