精华内容
下载资源
问答
  • vectorresize和reserve

    2018-11-06 13:07:06
    官方文档 resize:...reserve:http://www.cplusplus.com/reference/vector/vector/reserve/ resize Resizes the container so that it contains n elements. 1、I...

    官方文档

    resize:http://www.cplusplus.com/reference/vector/vector/resize/
    reserve:http://www.cplusplus.com/reference/vector/vector/reserve/

    resize

    Resizes the container so that it contains n elements.
    1、If n is smaller than the current container size, the content is reduced to its first n elements, removing those beyond (and destroying them).
    如果n比当前容器size小,当前容器内容会被缩减到前n个,多余的被清除。
    2、If n is greater than the current container size, the content is
    expanded by inserting at the end as many elements as needed to reach a
    size of n. If val is specified, the new elements are initialized as
    copies of val, otherwise, they are value-initialized.
    如果n比当前容器的size大,容器size或被扩充到n,如果这扩充的n个数指定了数值,则填入指定数值,否则,为默认值。
    3、If n is also greater than the current container capacity, an automatic
    reallocation of the allocated storage space takes place.
    如果n比当前容器的容积都大,内容空间会被重新分配。
    Notice that this function changes the actual content of the container
    by inserting or erasing elements from it.
    注意这个函数会影响容器的size。

    reserve

    Request a change in capacity Requests that the vector capacity be at
    least enough to contain n elements.

    1、If n is greater than the current vector capacity, the function causes
    the container to reallocate its storage increasing its capacity to n
    (or greater).
    如果n大于当前容器容积,容器会重新分配内存。
    2、In all other cases, the function call does not cause a reallocation
    and the vector capacity is not affected.
    其他情况,不产生影响
    Note:This function has no effect on the vector size and cannot alter its
    elements.
    这个函数对size 没有影响,也不会改变元素值。

    size和capacity辨析

    类比:

        int a[10],index=5;
        for(int i=0;i<index;i++) cin>>a[i]
    

    10是我们开辟的空间大小,5是我们实际使用的空间,此空间的单位是元素个数,而非字节。
    那么对应的capacity对应开辟空间,size对应使用空间。

    测试代码

        #include <iostream>
        #include <vector>
        using namespace std;
        
        int main(){
        	vector<int> a;
        	a.reserve(100);
        	cout<<a.size()<<"  "<<a.capacity()<<endl;
        	a.resize(150);
        	cout<<a.size()<<"  "<<a.capacity()<<endl;
        	a.reserve(50);
        	cout<<a.size()<<"  "<<a.capacity()<<endl;
        	a.resize(50);
        	cout<<a.size()<<"  "<<a.capacity()<<endl;
        } 
    

    结果
    在这里插入图片描述

    展开全文
  • vector性能调优之resizereserve

    千次阅读 2019-01-21 01:22:26
    vectorresizereserve reserve()函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size) resize() 函数( void resize( size_type size, TYPE val ) )改变当前vector的大小为size,且对新...

    vector的resize与reserve

    reserve()函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)

    resize() 函数( void resize( size_type size, TYPE val ) )改变当前vector的大小为size,且对新创建的元素赋值val

    在这里插入图片描述
    (翻译:

    调整容器大小以包含count元素。

    如果当前大小大于count,则容器将被缩减为其第一个count元素,就像重复调用pop_back()一样。

    如果当前大小小于count,则附加元素并用值的副本初始化。)

    resize和reserve函数本质都涉及了vector的内存存储空间,因为vector在内存中是连续存放的,所以当resize的空间大于现有的存储空间(capacity() 函数 返回当前vector在重新进行内存分配以前所能容纳的元素数量.)时,会重新选择更大的空间,并将所有元素复制过去。resize在初始化内存容量时有对值的初始化,所以此时push_back会产生size+1,内存容量不够,重新寻找更大的内存空间并复制所有元素,所以这个过程是很费事的。

    void testResize(){
        vector<int> vector1;
        vector1.resize(10);
        vector1.push_back(1);
        vector1.push_back(2);
        vector1.push_back(3);
        cout<<"vector1的长度:"<<vector1.size()<<endl;//vector1的长度:13
        for_each(vector1.begin(),vector1.end(),[](int x){cout<<x<<" ";});//0 0 0 0 0 0 0 0 0 0 1 2 3
        cout<<endl<<"当前vector在重新进行内存分配以前所能容纳的元素数量:"<<vector1.capacity()<<endl;//20
    }
    void testReserve(){
        vector<int> vector1;
        vector1.reserve(10);
        vector1.push_back(1);//vector1的长度:3
        vector1.push_back(2);//1 2 3
        vector1.push_back(3);
        cout<<"vector1的长度:"<<vector1.size()<<endl;//vector1的长度:13
        for_each(vector1.begin(),vector1.end(),[](int x){cout<<x<<" ";});//0 0 0 0 0 0 0 0 0 0 1 2 3
        cout<<endl<<"当前vector在重新进行内存分配以前所能容纳的元素数量:"<<vector1.capacity()<<endl;//10
    }
    
    

    插入测试

    接下来探讨插入的效率的实例,分别尝试在插入大数据3.8GB和小数据380MB时,各种情况的实现。

    (1)push_back直接插入

    结论:费事,在插入的过程中,不断寻找“庇护所”,不断“迁移大本营”,舟车劳顿效率低下

    void testPushBack_bigsize(){
        vector<int> vector1;
        clock_t start = clock();
        for (int i = 0; i < 1000000000; ++i) {//3814MB
            vector1.push_back(i);
        }
        cout <<"共耗时:"<< (clock() - start)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:42s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:1000000000 capacity:1073741824
        clock_t start2 = clock();
        vector1.push_back(1);
        cout <<"共耗时:"<< (clock() - start2)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:0s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:1000000001 capacity:1073741824
    }
    

    (2)先reserve在push_back

    结论:先分配空间再进行后续处理,能够有效的减少插入时间的损耗,耗时占原插入方式的1/3到1/2之间。

    void testPushBack_byReserve_bigsize(){
        vector<int> vector1;
        vector1.reserve(1000000000);//3814MB
        clock_t start = clock();
        for (int i = 0; i < 1000000000; ++i) {
            vector1.push_back(i);
        }
        cout <<"共耗时:"<< (clock() - start)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:17s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:1000000000 capacity:1000000000
        clock_t start2 = clock();
        vector1.push_back(1);
        cout <<"共耗时:"<< (clock() - start2)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:76s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:1000000001 capacity:2000000000
    }
    void testPushBack_byReserve_smallsize(){
        vector<int> vector1;
        vector1.reserve(100000000);//381MB
        clock_t start = clock();
        for (int i = 0; i < 100000000; ++i) {
            vector1.push_back(i);
        }
        cout <<"共耗时:"<< (clock() - start)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:1s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:100000000 capacity:100000000
        clock_t start2 = clock();
        vector1.push_back(1);
        cout <<"共耗时:"<< (clock() - start2)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:2s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:100000001 capacity:200000000
    }
    

    (2)先resize在利用坐标进行赋值(相当于插入)

    结论:在分配空间时直接对空间进行初始化,赋予初值,极大提升了存储的速率。但是在resize后进行push_back是不明智的选择。

    void testinsert_byResize_bigsize(){
        vector<int> vector1;
        vector1.resize(1000000000);
        clock_t start = clock();
        for (int i = 0; i < 1000000000; ++i) {
            vector1[i]=i;
        }
        cout <<"共耗时:"<< (clock() - start)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:3s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:1000000000 capacity:1000000000
        clock_t start2 = clock();
        vector1.push_back(1);
        cout <<"共耗时:"<< (clock() - start2)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:66s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:1000000001 capacity:2000000000
    }
    void testinsert_byResize_smallsize(){
        vector<int> vector1;
        vector1.resize(100000000);
        clock_t start = clock();
        for (int i = 0; i < 100000000; ++i) {
            vector1[i]=i;
        }
        cout <<"共耗时:"<< (clock() - start)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:0s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:size:10000000 capacity:10000000
        clock_t start2 = clock();
        vector1.push_back(1);
        cout <<"共耗时:"<< (clock() - start2)/ CLOCKS_PER_SEC <<"s"<<endl;//共耗时:2s
        cout <<"size:"<<vector1.size() << " capacity:" << vector1.capacity() << endl;//size:10000001 capacity:20000000
    }
    

    vector优化结论

    防止reallocate内存,而导致的数据拷贝产生的额外耗时

    vector在push_back的时候,如果空间不足,会自动增补一些空间,如果没有预留的空间可用
    就直接申请另一块可用的连续的空间,把数据拷贝过去,然后删除旧空间,使用新空间
    结果造成效率低下 。

    可以通过以下两种组合来防止reallocate.

    1. vector::resize() 使用array index,效率最高,但是需要提前知道size大小

    2. vector::reserve()使用 push_back(),效率一般,较原生有一定提升。

    展开全文
  •  ...而resize改变了vector的capacity同时也增加了它的size!原因如下:      reserve是容器预留空间,但在空间内不真正创建元素对象,所以在没有添加新的对象之前...
          vector 的reserve增加了vector的capacity,但是它的size没有改变!而 resize 改变了vector的capacity 同时也增加了它的size!
    原因如下:
          reserve是容器预留空间,但在空间内不真正创建元素对象,所以在没有添加新的对象之前,不能引用容器内的元素。 加入新的元素时,要调用push_back()/insert()函数。

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

         

    两个函数的参数形式也有区别的,reserve函数之后一个参数,即需要预留的容器的空间;resize函数可以有两个参数,第一个参数是容器新的大小,
    第二个参数是要加入容器中的新元素,如果这个参数被省略,那么就调用元素对象的默认构造函数。下面是这两个函数使用例子:
    例子1:
    vector<int> myVec;
    myVec.reserve( 100 );     // 新元素还没有构造,
                                           // 此时不能用[]访问元素
    for (int i = 0; i < 100; i++ )
    {
         myVec.push_back( i ); //新元素这时才构造
    }
    myVec.resize( 102 );      // 用元素的默认构造函数构造了两个新的元素
    myVec[100] = 1;           //直接操作新元素
    myVec[101] = 2;  
    例子2:
    #include <vector>
    #include <iostream>
    using namespace std;

    int main(int argc, char* argv[])
    {
        vector<int> vect;
       
        vect.push_back(1);
        vect.push_back(2);
        vect.push_back(3);
        vect.push_back(4);
        vect.reserve(100);
        cout<<vect.size()<<endl;  //size为4,但是capacity为100
        int i = 0;
        for (i = 0; i < 104; i++)
        {
            cout<<vect[i]<<endl;
        }
        return 0;
    }
    例子3:
    #include <vector>
    #include <iostream>
    using namespace std;

    int main(int argc, char* argv[])
    {
        vector<int> vect;   
        vect.push_back(1);
        vect.push_back(2);
        vect.push_back(3);
        vect.push_back(4);
        vect.resize(100);    //新的空间不覆盖原有四个元素占有的空间,现在size和capacity都是100
        cout<<vect.size()<<endl;
        int i = 0;
        for (i = 0; i < 104; i++)
        {
            cout<<vect[i]<<endl; 
        }
        return 0;
    }
    例子4:
    #include <vector>
    #include <iostream>
    using namespace std;

    int main(int argc, char* argv[])
    {
        vector<int> vect;       
        vect.resize(100);    //分配100个空间
        vect.push_back(1);
        vect.push_back(2);
        vect.push_back(3);
        vect.push_back(4);
        cout<<vect.size()<<endl; //现在size和capacity都是104
        int i = 0;
        for (i = 0; i < 104; i++)
        {
            cout<<vect[i]<<endl; 
        }
        return 0;
    }
          从上面例子可以看出,不管是调用resize还是reserve,二者对容器原有的元素都没有影响。

    展开全文
  • vector容器中resizereserve的区别

    万次阅读 2017-03-19 21:08:43
    首先申明resize()和reserve()这两个成员函数都是Vector的公有成员函数(public member function) 一、先了解vector容器的构成: 1.首先明白vector是一种顺序容器(申请的内部空间是连续的) 2.它的底层是由类模板...

    Vector中的resize()reserve()的区别

    我用的是VS2013编译器
    首先申明resize()和reserve()这两个成员函数都是Vector的公有成员函数(public  member function)
    一、先了解vector容器的基本构成:
    1.首先明白vector是一种顺序容器(申请的内部空间是连续的:类似数组)
    2.它的底层是由类模板实现的
    3.vector的基本模板:
      template<class T>
    class vector
    {
      public:
        vector()
    {};
       ~vector()
    {};
    ...
      protected:
    T* _arr;//vector的内部命名
    size_t _sz;//记录该数组_arr中存储的有效数据的个数
    size_t _capacity;//记录该数组_arr开辟的总空间大小
    };
    4.stl库中英文版详解:(如下图)





    二、这两个成员函数的意义:
    resize():重新申请并改变当前vector对象的有效空间大小
    reserve():重新申请并改变当前vector对象的总空间(_capacity)大小




    三、单独讲解resize()和reserve()
    1、resize()

    该函数的模板:
    void  resize(size_t sz,T c=T());  

    1.总的来讲:resize()就是重新申请有效空间的大小;
    2.再用运该函数的时候最多可以有两个参数,至少要有一个参数(sz:表示你要申请多少有效元素空间的个数)
    3.第一个参数sz:代表的是当前要申请的有效元素的个数;
    4.第二个参数c:代表的是给这sz个有效空间赋一个初始值(默认为T()(T()表示当T为什么类型时,c就是什么类型的默认值eg:T为int  则:T()为0,T为char 则:T()为‘\0’))
    5.该函数可以直接由vector的对象调用
    6.该函数无返回值

    vector中resize()应用的举例:



    由上述例子总结:
    1.resize()可以改变有效空间的大小;
      2.resize()有改变默认值的功能,但该改变的范围是有限制的 这个范围是当前设置的sz范围内
    3.当新设置的sz值大于之前的sz时,默认参数只作用于多开辟的那些空间
    4.当resize的sz(size())改变时capacity的大小也会随着改变,但是当reserve()改变capacity的大小后,size()的大小并不会随之改变它仍然保持的是原来有效元素的个数;

    2、reserve()
    该函数的模板:
    void reserve(size_t n);

    1.与resize()函数最直接的区别是:reserve()只有一个参数;
    2.reserve()中的参数n改变的是总空间(_capacity)的大小;(注意:他开辟出来的n
    个空间并不代表就都是有效空间,只有size()大小的空间才是有效空间)
    3.该函数无返回值

    vector中reserve()应用的举例:







    另附:(目的:熟悉一下list 中有那些接口)
    List(链表)(简讲)



    list中没有reserve(),但是有resize();

    展开全文
  • reserve是容器预留空间,但并不真正创建元素对象,在创建对象之前,不能引用容器内的元素,因此当加入新的元素时,需要用push_back()/insert()函数。 resize是改变容器的大小,并且创建对象,因此,调用这个函数...
  • C++ vector中的resizereserve,sizecapacity函数讲解

    万次阅读 多人点赞 2018-07-18 22:26:20
    在介绍resize(),reserve(),size()capacity()函数之前,先简单介绍一下c++中vector的概念。 vector:顺序容器(可变大小数组)。支持快速随机访问。在尾部之外的位置插入或删除元素可能很慢。 既然vector是个...
  • vectorresize函数和reserve函数

    千次阅读 2018-10-17 14:15:10
    博客原文:...对于C++的vector容器模板类,存在sizecapacity这样两个概念,可以分别通过vector的size()capacity()方法获得该vector当前的sizecapa...
  • vector提供两个方法,resize和reverse方法。resize执行扩容操作并且自动执行构造函数。reverse仅仅修改容量大小,及vector的capacity的大小。vector的clear方法,仅仅修改有效数据数量,不回收内存。...
  • vectorreserveresize区别 一、基本概念 1、capacity 指容器在分配新的存储空间之前能存储的元素总数。 2、size 指当前容器所存储的元素个数 二、reserveresize 1.区别 1、reserve()只修改capacity大小,不修改...
  • size指目前容器中实际有多少元素,对应的resize(size_type)会在容器尾添加或删除一些元素,来调整容器中实际的内容,使容器达到指定的大小。 Capacity Capacity指最少要多少元素才会使其容量重新分配,对应reserve...
  • reserve是容器预留空间,但并不真正创建元素对象,在创建对象之前,不能引用容器内的元素,因此当加入新的元素时,需要用push_back()/insert()函数。 resize是改变容器的大小,并且创建对象,因此,调用这个函数...
  • C++中resize和reserve的区别

    千次阅读 多人点赞 2019-07-11 10:59:46
    resize和reserve接口的共同点是它们都保证了vector的空间大小(capacity)最少达到它的参数所指定的大小。 因两接口的源代码相当精简,以至于可以在这里贴上它们: void resize(size_type new_size) { resize...
  • C++ vectorresizereserve的比较

    千次阅读 2020-09-16 18:33:04
    在介绍resize()与reserve()函数之前,可以先简单了解一下vector vector:https://blog.csdn.net/Gary_ghw/article/details/103868209 基本概念 1、capacity:指容器在分配新的存储空间之前能存储的元素总数 2、...
  • 测试代码如下,并在下文将给出6条测试结论: ...vector> #include <iostream> using namespace std; int main(int argc, char* argv[]) { vector<int> vect; vect.push_back(1); vect.push_b...
  • C++ resize和reserve详解

    千次阅读 2018-11-06 19:07:53
    vector&gt; using namespace std; void display(const vector&lt;int&gt;&amp; vec, char* vecName) { cout &lt;&lt;" "&lt;&lt; vecName &lt;&lt; "
  • reserve函数用来给vector预分配存储区的大小,即capacity的值,但是没有给这段内存进行初始化。reserve的参数n推荐预分配内存的大小,实际分配的可能等于或大于这个值。 当调用函数时,n的值如果大于capacity的值,...
  • STLvectorreserve()和resize()区别

    千次阅读 2018-03-17 13:43:14
    一 STL中resize()函数的作用是改变vector元素个数 resize(n,m)第二个参数可以省略 n代表改变元素个数为n,m代表初始化为m .主要有三层含义:1.如果n比vector容器的size小,结果是size减小到n,然后删除n之后的数据...
  • vectorresize:既分配了空间,也创建了对象,会调用构造函数 vectorreservereserve()表示容器预留空间,但不是真正的创建对象,需要通过insert()或push_back()等操作创建对象 reserve()只修改capacity大小,不...
  • std::vectorresize()和reserve()区别

    千次阅读 2019-03-22 15:08:50
    在STL容器中vector用的还是比较多的,但是在使用时,会对resize()和reserve()的使用产生迷惑,现在就对这一情况做个对比: resize():改变的是size()与capacity()的大小 (1)、比原来的变小之后,后面的会被截断 ...
  • 系统是CentOS 7 说明都在代码中的注释里... //size是当前vector中的元素个数,capacity是vector当前可容纳的元素个数 //当使用push_back等操作使得size超过capacity后,capacity会翻倍 //resize会更改size大小,若siz
  • vector容器resize和reserve探究一级目录二级目录三级目录 一级目录 二级目录 三级目录
  • vectorresize()和reserve()函数的区别 reserve是容器预留空间,但并不真正创建元素对象,在创建对象之前,不能引用容器内的元素,因此当加入新的元素时,需要用push_back()/insert()函数。 resize是改变...
  • resize() 【rɪ'zɜːv】类似 realloc(); reserve类似 malloc(); 另外 reverse【rɪ'vɜːs】 是stl 算法,反转容器中的元素
  • C++ vectorreserve和resize区别 vectorreserve增加了vector的capacity,但是它的size没有改变!而resize改变了vector的capacity同时也增加了它的size! 原因如下: reserve是容器预留空间,但在空间内不真正...
  • 但是有时候我们希望在vector创建之后就按照下标来访问vector中的元素,如果直接v[i]是会报错的,因为此时vector的size是0,其中还没有元素。如何初始化vector到我们想要的大小呢。这就需要用到vector的resizeh函数了...
  • 文章目录问题描述releasedebug的区别sizecapacityresizereserveresize_Reservereserve...3. resize和reserve区别的意义又是什么?4. reserve会改变空间大小,那么地址会变,得去验证一下 问题描述 今天遇到...
  • resize和reserve的区别

    2017-03-22 09:58:00
    首先必须弄清楚两个概念: 1.capacity 指容器在分配新的存储空间之前能存储的元素总数。 ...在弄清这两个概念以后,很容易懂resize和reserve的区别 1).reserve表示容器预留空间,但并不...
  • C++ vectorreserve和resize详解 vectorreserve增加了vector的capacity,但是它的size没有改变!而resize改变了vector的capacity同时也增加了它的size! 原因如下: reserve是容器预留空间,但在空间内不真正...

空空如也

空空如也

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

resize和reservevector