精华内容
下载资源
问答
  • STL vector

    2021-02-06 20:45:49
    vector是个顺序容器,可以认为是个变长数组。与数组一样,vector是使用连续的存储空间来保存元素,这意味着可以使用指向其元素的常规指针的偏移量来访问它们的元素,而且效率与数组一样高。vector的随机存取效率很高...

    vector是个顺序容器,可以认为是个变长数组。与数组一样,vector是使用连续的存储空间来保存元素,这意味着可以使用指向其元素的常规指针的偏移量来访问它们的元素,而且效率与数组一样高。vector的随机存取效率很高,能达到O(1)的时间复杂度,但也和数组一样,当从中间插入或者删除元素时,需要移动元素,效率比较低。但从其末尾添加或删除元素也相对高效。

    但与数组不同的是,vector的大小可以动态变化,容器在需要的时候会自动扩容。vector是使用动态分配的内存来保存元素,当插入一个新元素时如果内存已经不够了就需要重新申请一块更大的内存空间,再将所有的元素拷贝到新内存空间,然后再释放掉旧的内存空间同时销毁旧的元素,最后再插入新元素。在这个过程中,复制元素的时候需要调用元素的构造函数,销毁旧元素的时候也需要调用析构函数。也就是说这个过程可能比较耗时,特别是元素的构造析构比较复杂或者元素数量比较多的时候。所以为了避免过多的内存拷贝和元素构造析构,vector容器会多分配额外的内存空间,也就是说vector的的实际内存容量可能大于容纳其元素所需的存储空间(即其大小)。当vector需要扩容的时候,不同的标准库的扩容策略可能不太一样,GCC的扩容策略是两倍扩容,即新分配的内存空间是旧内存空间的两倍。

    扩容异常安全 

    vector 自动扩容的异常安全级别是strong guarantee,成功或者回滚保证。就是说即使在自动扩容的时候抛出了异常(比如bad_alloc内存不足异常),vector已能够保证原有的数据不会被破坏,或者说是自身不会被改变。因为在扩容时是分三步走:新开辟一片内存空间,拷贝元素,销毁旧元素,一般只有前两部可能抛出异常,但是即使前两步抛出了异常,因为这时候旧元素并没有被销毁,所以还是能够回滚到之前的状态。

    移动构造

    如果元素定义了移动构造函数,但是由于vector需要保证 strong guarantee异常安全,除非元素的移动构造函数保证不会抛异常并显示标识为noexcept,vector在扩容时才会采用移动构造函数。因为移动构造函数和拷贝构造函数不同,拷贝构造函数不会破坏旧元素,而移动构造函数通常是从旧元素“窃取”资源,也就是移动构造函数会改变旧元素,如果抛异常了就不能保证能回滚到之前的状态。

    迭代器类型

    以下这几对迭代,分别组成的空间都是前开后闭空间。

    begin,end正向迭代器
    rbegin,rend反向迭代器
    cbegin,cend常量const正向迭代器
    crbegin,crend常量const反向迭代器

    容量大小

    size元素数量
    max_size可能最大的元素数量
    resize改变元素数量
    empty判断是否为空
    capacity容量大小
    reserve改变容量大小
    shrink_to_fit  

     

    关于size、capacity和max_size的区别参考这个例子:

    // comparing size, capacity and max_size
    #include <iostream>
    #include <vector>
    
    int main ()
    {
      std::vector<int> myvector;
    
      // set some content in the vector:
      for (int i=0; i<100; i++) myvector.push_back(i);
    
      std::cout << "size: " << myvector.size() << "\n";
      std::cout << "capacity: " << myvector.capacity() << "\n";
      std::cout << "max_size: " << myvector.max_size() << "\n";
      return 0;
    }

    这个程序可能的输出如下

    size: 100 capacity: 128 max_size: 1073741823

    resize

    来看一下resize,这个成员函数是用来改变vector元素的数量。

    void resize (size_type n);
    void resize (size_type n, const value_type& val);

     参数n为调整大小后的元素数量。那么可能会有以下三种情况:

    1. n小于当前元素数量,那么就会收缩到前n个元素,或者说只保留前n个元素,其余的元素会被移除并销毁。
    2. n大于当前元素数量,那么就会在当前最后一个元素后面插入新的元素,直到元素数量达到n。如果传递了val这个参数,那么新元素就按val来初始化,否则就是value-initialization。值初始化的详细介绍见这个链接:value-initialization。这里可以先简单认为是默认初始化,一般是模式为0.
    3. 如果n比容量capacity还大,那么vector就会自动扩容。

    示例:

    // resizing vector
    #include <iostream>
    #include <vector>
    
    int main ()
    {
      std::vector<int> myvector;
    
      // set some initial content:
      for (int i=1;i<10;i++) myvector.push_back(i);
    
      myvector.resize(5);
      myvector.resize(8,100);
      myvector.resize(12);
    
      std::cout << "myvector contains:";
      for (int i=0;i<myvector.size();i++)
        std::cout << ' ' << myvector[i];
      std::cout << '\n';
    
      return 0;
    }

    输出为: 

    myvector contains: 1 2 3 4 5 100 100 100 0 0 0 0
    

    resize要注意迭代器失效问题,在容器收缩的情况下,所有未删除元素的迭代器、指针和引用在调整大小后仍然有效,并指向它们在调用前引用的相同元素。如果容器展开,end迭代器将失效;如果重新分配了存储空间,所有与该容器相关的迭代器、指针和引用也将失效。

    对于异常问题,如果n小于或等于容器的大小,resize函数永远不会抛出异常(no-throw guarantee)。如果n更大,并且发生了重新分配,如果元素的类型是可复制的或者移动操作不会抛异常,则在exception的情况下能保证容器不会发生变化(strong guarantee)。

     reserve

    void reserve (size_type n);

    reserve是用来调整vector容量大小到至少能容纳n个元素。 

    如果n大于当前vector容器的容量,该函数将导致容器重新分配存储空间,将容量增加到n(或更大)。在所有其他情况下,函数调用不会导致重新分配,vector的容量也不会受到影响。这个函数对vector大小没有影响,并且不能改变其元素。

     这个函数主要是用来给vector预先扩容,比如这种场景:依次往一个空vector中插入100个元素。最开始vector容量为1,在插入的过程中需要多次扩容最终才能容下100个元素,它的容量变化可能是这样的:1,2,4,8,16,32,64,128.但是假如一开始就用reserve来预留100容量,那么这个过程只需要扩容一次。

     

    元素访问

    operator[]像数组一样访问
    at访问某个元素,有越界保护
    front返回第一个元素
    back返回最后一个元素
    data返回vector存储数据的内存起始指针,之后可以通过指针访问元素

      

    元素 操作

    assign给元素赋值
    push_back从末尾添加一个元素
    pop_back删除最后一个元素
    insert插入一个元素
    erase删除一个元素
    clear清空所有元素
    emplace 构造和插入元素,
    swap交互元素内容
    emplace_back 构造元素并把它从末尾插入

     

    erase

    iterator erase (const_iterator position);
    iterator erase (const_iterator first, const_iterator last);


    删除某个位置或者某个范围(([first,last))前闭后开区间)内的元素。由于vector是使用数组作为底层存储结构,如果删除的位置不是末尾vector就需要将删除范围之后的元素重新分配到新的位置。所以相对于list和 forward_list,vector的erase操作通常比较低效。
    参数
    position
    指向准备要删除的元素的迭代器。
    first,last 指定删除的范围,[first,last)组成一个前闭后开区间,从first到last范围内的元素都会被删除,包括first指向的元素,但是不包含last指向的元素。
    返回值是一个迭代器,它指向删除范围的最后一个元素的下一个元素的新位置,因此元素被删除之后,后面的元素要移动到新的位置。
    算法复杂度是总共要删除的元素个数加上删除范围最后一个元素之后的所有元素的线性叠加。
    指向first(或position)之前的迭代器,指针和引用都保持有效,而指向first(或position)及之后的会失效。
    异常安全
    如果移除的元素包含容器的最后一个元素,那么能够保证不会抛异常(no-throw guarantee)。因为这种情况不需要移动元素。
    否则只能保证basic guarantee,容器能回到一个有效状态。

    insert

     

    single element (1)
    iterator insert (iterator position, const value_type& val);
    
    fill (2)
        void insert (iterator position, size_type n, const value_type& val);
    
    range (3)
    template <class InputIterator>
        void insert (iterator position, InputIterator first, InputIterator last);


    在position指定的位置插入新元素,如果容器内存不足以容纳新元素就好自动扩容。和erase一样,从中间insert一个元素需要移动元素效率相对比较低。
    返回值是一个指向第一个新插入的元素的迭代器。
    算法复杂度是要插入的元素数量和要移动的元素数量的线性叠加。

    上表的几个插入操作函数基本差不多,要注意一点是迭代器失效问题。如果发生了内存重新分配,所有与容器相关的迭代器、指针和引用都将失效。insert和emplace可以在任何位置插入元素,只有指向插入位置之前元素的迭代器、指针和引用不会失效,其它的都会失效。push_back,emplace_back由于是从尾部插入,之后导致end迭代器失效。

     pop_back函数之会导致end迭代器和指向的被移除元素的迭代器失效。

    emplace,emplace_blace和insert、push back的区别是它们是直接在vector的内存空间直接用参数来构造元素,避免了不必要的拷贝。

     

    展开全文
  • STL vector成员函数详解

    2021-04-20 21:37:13
    一、 常用简单成员函数 vector::push_back(Type val) //将val添加到向量尾部 ...vector::clear() //删除向量,并没有释放vector,还是占有capacity个空间,如果要释放空间,可使用 swap(vector<_Ty>()

    一、 常用简单成员函数

    vector::push_back(Type val) //将val添加到向量尾部
    vector::pop_back()  //将最后一个元素删除
    iterator vector::begin() //返回指向第一个元素的迭代器
    iterator vector::end() //返回指向最后一个元素之后的迭代器
    vector::clear() //删除向量,并没有释放vector,还是占有capacity个空间,如果要释放空间,可使用 swap(vector<_Ty>()).
    vector::at(n)  //等效于vector[n] 返回第n个位置的引用
    bool vector::empty()  //向量是否为空
    Type vector::front() //返回第一个元素的引用
    Type vector::back()  //返回最后一个元素的引用
    vector::shrink_to_fit()  //将capacity变为和size一样大
    allocator_type vector::get_allocator() //得到分配器
    

    二、vector::size() vector::capacity() vector::max_size()

    size_type size()返回的是数组的元素的个数,capacity是数组可容纳元素的个数,如果capacity的大小不够容纳插入的新元素时,vector就会从新找一个更大的连续的空间,并将之前的值赋值到新空间,释放原来的空间,所以在内存中的地址会变,这时原来的迭代器也就会失效。

    经过测试,未初始化的数组capacity为0,若初始化了vector的大小则capacity一般和size相等。当capacity不够时,会按照一定的算法扩容(实测:至少扩大原来capacity的一半;如size从100→101,则capacity从100→150;但是如果一次性插入的元素超过原来的一半,则capacity会扩充到刚好,如size从100→200,则capacity从100→200)。
    size_type max_size() 返回所能设置的最大capacity.

    三、vector::erase()

    iterator vector::erase(itrator location);
    iterator vector::erase(iterator first, iterator last);
    

    erase(itrator location)删除location位置的元素,并将之后的元素向前移动,迭代器location本身所指的内存中的位置并没有改变,但是所指位置的值变为了下一个位置的元素(因为向前移动了)
    erase(iterator first, iterator last) 删除迭代器first到last之间(不包括last)的元素,并将之后的元素移动位置,执行后迭代器location指向内存中的位置没有变,指向的值变成了之前的*last。

    四、vector::insert() empalce()

    1. insert()

    iterator vector::insert(iterator loc,const TYPE &val)
    //在loc插入val,返回指向val的迭代器(迭代器指向地址不变),loc原本位置的元素及之后的元素向后移
    void vector::insert(iterator loc,size_type num,const TYPE &val)
    //在loc插入num个val;loc原本位置的元素及之后的元素向后移
    void vector::insert(iterator loc,iterator start,iterator end)
    //在loc插入区间[start,end)的所有元素,,loc原本位置的元素及之后的元素向后移
    

    iterator vector::insert(iterator loc,const TYPE &val), 迭代器loc会指向val(因为loc本来位置的元素往后移了一次)

    C++11:

    iterator insert(const_iterator _Where, const _Ty& _Val) { // insert _Val at _Where
            return emplace(_Where, _Val);
        }
        //函数重载,左值、右值引用 const左值进入此函数
        //这时_Val是一个const引用,传入emplace
    
    iterator insert(const_iterator _Where, _Ty&& _Val) { // insert by moving _Val at _Where
            return emplace(_Where, _STD move(_Val));
        }
        //函数重载,常量、表达式进入此函数
        //_Val是右值引用,为什么还要move?
    

    2. emplace()

    iterator emplace(const_iterator _Where, _Valty&&... _Val)
    //无重载, ...表示可变参数模板,
    decltype(auto) emplace_back(_Valty&&... _Val)
    

    分别表示在iter或最后的位置插入一个元素val,iter原本位置及之后的元素依次向后移。

    C++ 11对大部分容器都新加了这两个函数,其中map的使用方式比较特殊;
    它们同insert和push_back的区别:最大的作用是避免产生不必要的临时变量,临时变量要申请和释放内存。如下:
    (通过测试,insert会构造临时变量Foo,再将Foo拷贝给vector,再释放Foo; C++11的insert会构造临时变量Foo再调用emplace,用拷贝的方式将Foo给vector,再释放原来的Foo。而直接调用emplace在emplace函数内构造Foo,构造时的地址就在vector内,然后用移动赋值的方式将Foo交给vector);另外,vector的insert将所有类型都传入emplace进行处理,但是list的insert只将常量和表达式传入emplace处理,这种区别的原因是什么呢?)
    实测:现在的insert(iterator loc,const TYPE &val) 直接调用 emplace

    struct Foo {
    int vali;
    double vald;
        Foo(int n, double x):vali(n),vald(x){};
    };
    
    std::vector<Foo> v;
    v.emplace(someIterator, 42, 3.1416);        // 没有临时变量产生
    v.insert(someIterator, Foo(42, 3.1416));    // 需要产生一个临时变量
    v.insert(someIterator, {42, 3.1416});       // 需要产生一个临时变量
    

    五、 vector::assign(iterator start, iterator end)

    清除原有的数据,将迭代器[start,end)的内容赋给vector;
    若原vector的capacity大于等于新数据的长度,则capacity不变,不然capacity等于新数据的长度。
    可以将其他容器的迭代器的内容赋值给vector,但是数据类型最好相同,否则会相应转换

    set<int> myset;
    myset.insert(1);
    myset.insert(3);
    myset.insert(2);
    
    vector<int> myvec;
    myvec.assign(myset.begin(),myset.end());
    
    从int → float double 则会转换为相应类型
    从int → char 则会转换为ASCII码,具体的 33 → '\x33' 表示字符'!'
    从char → int ,例:'!' → 33
    

    六、 vector::reserve(int n)

    设置vector的capacity的大小(向系统申请连续的内存空间),如果n超过max_size(),则抛出异常。
    如果n小于当前的capacity则不起作用。

    七、 vector::resize()

    void vector::resize(int n)
    void vector::resize(int n, Type val)
    重新设置vector的大小;
    若n小于vector.size(),则删除[vector.begin()+n,vector.end)之间的元素;
    若n大于vector.size(),则添加元素,第一个添加T(),第二个添加val。

    八、vector::empalce(const iterator iter, Type val)

    九、vector::data()

    C++11 新加

    _Ty* data()
    返回指向vector首地址的指针(_Mypair._Myval2._Myfirst),使得可以直接操控vector的底层数据
    

    十、vector::swap(vector &x)

    该成员函数会在*this和x之间互相交换被控序列。如果get_allocator()==x.get_allocator(),它将在常数时间内完成交换并且不会抛出任何异常,另外,他还不会导致任何指向这两个被控序列中元素的引用、指针和迭代器无效。否则,它将以与这两个被控序列的元素个数成比例的次数调用元素的构造函数以及为元素赋值。

    swap只能同类型之间进行交换。

    经测试,当长度、元素类型、维度都不同时,get_allocator()==x.get_allocator()都成立,暂时没有测试出不成立的情况。

    swap将所有内容都交换,包括capacity;交换后,原有的迭代器指向的内存地址没有变

    十一、迭代器相关

    iterator vector::rbegin()  //返回逆迭代器,指向最后一个元素 ,用++则指向倒数第二个元素
    iterator vector::rend()  //返回逆迭代器,指向第一个元素的前一个位置
    
    //c++11 新加函数,将指向元素视为const,不可用获得的迭代器修改
    iterator vector::cbegin()
    iterator vector::cend()
    iterator vector::crbegin()
    iterator vector::crend();
    
    

    十二、 _Unchecked_begin()

    pointer _Unchecked_begin() noexcept {
            return _Mypair._Myval2._Myfirst;
        }
    //返回指向首部的指针
    
    pointer _Unchecked_end() noexcept {
            return _Mypair._Myval2._Mylast;
        }
    //返回指向尾部的指针(最后一个元素的后面)
    

    十三、 分配器allocator

    _Myval2
         _Myfirst  //指向首地址 vector.begin()返回迭代器所指向的地址
         _Mylast  //指向最后一个元素之后 vector.end()返回迭代器指向的地址
         _Myend  //指向最后分配的内存首地址(capacity的大小)。
    
    展开全文
  • 三、当填充或复制到vector中时,最好选择 '=' 赋值而不是insert()或push_back()四、在迭代 vector 中的元素时,避免使用at() 函数五、vector别在头部插入数据6、vector插入数据时emplace_back比push_back效率高 ...


    简介

    用Bjarne Stroustrup的话来说:默认情况下,当你需要一个容器时使用 Vector。

    Vector 只是一个工具,像任何工具一样,它可以有效地使用,也可以无效地使用。

    本文介绍 6 种优化vector使用的方法,研究使用vector执行最常见编程任务的有效和低效方法,衡量我们通过有效使用vector获得的性能增益,并尝试理解为什么我们会获得性能增益。

    性能测试的实施方法

    用标准库 chrono 制作一个秒表记录函数运行时间,我们将每个测试运行100次取平均运行时间进行比较。

    代码放最后链接里。

    注意:结果测试用 Release,别用Debug。

    运行结果:
    在这里插入图片描述

    一 、通过提前保留向量的大小来避免不必要的重新分配和复制周期

    程序员喜欢vector是因为可以向容器中添加项目时无需提前担心容器的大小。但是,仅从容量为 0 的vector开始并在元素进来时添加它可能会花费相当多的运行时性能,如果你提前知道你的 vector 可以有多大,那么提前保留大小是值得的。

      // #1: 通过提前保留vector的大小,避免不必要的重新分配和复制周期。
        vector<BigTestStruct> testVector1;
        vector<BigTestStruct> testVector2;
        for (int i = 0; i < 100; i++)
        {
            sw.Restart(); //重置时间
            FillVector(testVector1); //添加一个数据结构体
            tg.test1 += sw.ElapsedUs(); //微妙
    
            sw.Restart();
            //重点:用reserve先储备10000个空间
            testVector2.reserve(10000);
            FillVector(testVector2);
            tg.test2 += sw.ElapsedUs();
    
            testVector1.clear(); //清除内容
            testVector1.shrink_to_fit(); //通过释放未使用的内存来减少内存使用
            testVector2.clear();
            testVector2.shrink_to_fit();
        }
        cout << "\n无预约填充vector的平均时间:" << (tg.test1 / 100) << endl;
        cout << "有无预约填充vector的平均时间:" << (tg.test2 / 100) << endl;
    

    在我电脑上跑,未提前保留大小用时 7027.3 微妙 , 前保留只需要 1950.07 微妙,性能提高71%

    在这里插入图片描述

    这背后的原因 Scott Meyers 在他的书 " Effective STL:50条有效使用STL的经验 " 中有解释。

    对于vector 和string,每当需要更多空间时,就会执行类似于realloc的操作。这种类似realloc的操作有四个部分:

    1. 分配一个新的内存块,它是容器当前容量的若干倍。在大多数实现中,vector 和string 容量每次增长 1.5 到 2 倍
    2. 将容器旧内存中的所有元素复制到新内存中
    3. 销毁旧内存中的对象
    4. 释放旧内存

    分配、回收、复制和销毁一套下来就是70%的性能。

    二、使用shrink_to_fit()来释放vector ,别用clear()或erase()清除内容而不释放内存。

    shrink_to_fit:通过释放未使用的内存来减少内存使用。

    clear:清除内容

    erase:擦除元素

    通过 erase() 或 clear() 方法从向量中删除元素不会释放vector分配的内存。

    在这里插入图片描述

    不要的内存一定要用shrink_to_fit释放掉。

    shrink_to_fit可能不是所有编译器都支持,可以使用swap。

    container<T>( c ).swap( c )
    
    container<T>().swap( c )
    

    将容器中的内容与其他内容交换。不对单个元素调用任何移动、复制或交换操作。

    三、当填充或复制到vector中时,最好选择 ‘=’ 赋值而不是insert()或push_back()

    在这里插入图片描述

    赋值非常有效,因为它知道它正在复制的向量的大小,并且只需要调用一次内存管理器来创建分配向量的内部缓冲区。

    四、在迭代 vector 中的元素时,避免使用at() 函数

    三种遍历vector的方法:

    1. 使用 iterator
    2. 使用 at()
    3. 使用下标 [ ]
      在这里插入图片描述

    结果:at() 函数是三种访问向量元素的方法中最慢的

    五、vector别在头部插入数据

    在这里插入图片描述

    相差太多,vector的头部插入是一个 O(1) 操作。向量越大,性能越差。

    6、vector插入数据时emplace_back比push_back效率高

    在这里插入图片描述

    代码

    https://blog.csdn.net/a15322910600/article/details/121282425

    展开全文
  • vector> #include<algorithm> //vector容器存放内置数据类型 //可以将vector理解为数组 void myPrint(int val) { cout << val << endl; } void test01() { //创建一个vector容器,数组 ...
    #include<iostream>
    using namespace std;
    #include<vector>
    #include<algorithm>
    //vector容器存放内置数据类型
    //可以将vector理解为数组
    void myPrint(int val) {
    	cout << val << endl;
    }
    void test01() {
    	//创建一个vector容器,数组
    	vector<int> v;
    	//向容器插入数据
    	v.push_back(10);
    	v.push_back(20);
    	v.push_back(30);
    	v.push_back(40);
    	//通过迭代器访问容器中数据
    	//注意这是指针形式    !!!
    	vector<int>::iterator itBegin = v.begin();   //起始迭代器  指向容器中第一个元素位置
    	vector<int>::iterator itEnd = v.end();   //起始迭代器  指向容器中最后一个元素的下一个位置
    
    	//第一种遍历方式
    	while (itBegin != itEnd) {
    		cout << *itBegin << endl;
    		itBegin++;
    	}
    
    	//第二种遍历方式
    	//将第一种的数据揉在一起
    	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
    		cout << *itBegin << endl;
    	}
    
    	//第三种遍历方式  利用STL提供遍历算法
    	for_each(v.begin(), v.end(), myPrint);
    }
    int main() {
    	test01();
    }

    展开全文
  • C++ STL vector构造函数

    2021-11-08 10:02:45
    std::vector<T,Allocator>::vector 1 vector(); vector() noexcept(noexcept(Allocator())); constexpr vector() noexcept(noexcept(Allocator())); 默认构造函数。使用默认构造的分配器构造一个空容器。 ...
  • vector> using namespace std; int main() { vector<int>a; for(int i=0;i<10;i++){ a.push_back(i);//在链栈的尾部插入一个元素 } a.pop_back();//删除尾部元素 a.erase(a.begin()+1);//删除...
  • //预留空间:减少vector在动态扩展容量时的扩展次数 //函数原型: //reserve(int len); //容器预留len个元素长度,预留位置不初始化,元素不可访问 #include<vector> #include<iostream> using namespace ...
  • C++ | C++ STL vector容器详解 vector 容器是 STL 中最常用的容器之一,它和 array 容器非常类似,都可以看做是对 C++ 普通数组的“升级版”。不同之处在于,array 实现的是静态数组(容量固定的数组),而 vector ...
  • vector<int> v; for (int i = 1; i <= 10; ++i) { v.push_back(i); } cout << v.size(); // 打印10 v[3] = v[5] = v[9] = 99; // 设置3个元素为99 remove(v.begin(), v.end(), 99); // 把所有等于...
  • C++ STL vector遍历方式及其效率分析++i和i++区别下标遍历迭代器遍历for_each遍历总结 ++i和i++区别 ++i使用的是i执行完+1后的值可以直接使用,而i++是先使用i然后在对i进行+1这样就需要一个临时变量去进行转储,...
  • void biSearch(int x,vector<int> v) { sort(v.begin(),v.end()); //Because the elements have to be ordered int flag=0; int low=0; int high=v.size()-1; int mid; while(low<=high) {
  • //vector& operator=(const vector &vec); //重载等号操作符 //assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给本身 //assign(n,elem); //将n个elem拷贝赋值给本身 #include<iostream> using ...
  • C++ STL Vector容器详解

    2021-11-01 21:57:57
    vector容器 1 vector基本概念 功能: vector数据结构和数组非常相似,也称为单端数组 vector与普通数组区别: 不同之处在于数组是静态空间,而vector可以动态扩展 动态扩展: 并不是在原空间之后续接新空间,...
  • //函数原型: //at(int idx); //返回索引idx所指的数据 //operator[]; //返回索引idx所指的数据 //front(); //返回容器中第一个数据元素 ...vector> void test01() { vector<int>v1; for (int i = 0; i <.
  • C++ STL vector容器详解

    2021-05-20 19:07:03
    C++ STL vector容器详解1、vector VS array2、vector迭代器3、vector空间容量4、vector空间扩充5、vector函数接口6、vector容器存放自定义对象 1、vector VS array vector的数据安排及操作方式与array非常相似,...
  • STL Vector

    2021-05-18 19:34:55
    vector> 实例化: vector<类型> v; 类型可以为int double char string 或者结构体均可。 v是定义vector的变量名。 注:vector就相当于一个变成的数组。 常用函数: v.size() 返回...
  • 一、vector的二维数组用法: 有时候我们在代码里会需要用到c语言的二维数组,但是c语言的二维数组会有一些不方便,比如二维数组的大小必须提前确定好,这时候就会想c++里面有没有能代替二维数组的数据结构呢,下面...
  • C++ STL Vector 两种常用排序方法(笔记) 目前有一个vector< Point > totalPoint 存储有从Point类型坐标点的向量,由于Point从Mat图像中获取时是乱序,现在需要按Point类型中的x从小到大进行排序 方法一:使用...
  • stl vector使用之resize和reserve的区别

    千次阅读 2021-11-30 09:06:40
    void resize (size_type n); void resize (size_type n, const value_type& val);...vector> #include <stdio.h> #include <algorithm> int main() { std::vector<int>
  • STL vector容器

    2021-04-01 23:50:34
    vectorSTL 中最常用的容器,和数组结构非常类似,也被称作单端数组; vector 容器和普通数组的区别:它们的不同之处在于,数组是静态空间(一旦给定了初始长度,无法修改),而 vector 容器可以动态扩展; 动态...
  • vector 的底层为顺序表(数组)。vector<T> (泛型) 容器是包含 T 类型元素的序列容器,和 array<T,N> 容器相似,不同的是 vector<T> 容器的大小可以自动增长,从而可以包含任意数量的元素;因此...
  • 1、为什么需要主动释放vector内存 来自 <... vector其中一个特点:内存空间只会增长,不会减小,援引C++ Primer:为了支持快速的随机访问,vector容器的元素以连续方式存放,每一个元素都紧...因此STL实现者..
  • STLvector和map容器案例

    2021-03-13 21:45:19
    STLvector和map容器案例 3.10.1案例描述 3.10.2实现步骤 代码示例: #include<iostream> #include<vector> #include<map> #include<ctime> #include<string> #define CEHUA 0 #...
  • C++ STL Vector(容器)学习

    2020-12-21 13:27:55
    本文参考博客链接及书籍:侯捷老师的《STL 源码剖析》在C++标准库中,STL容器是一些常用数据结构的实现,比如数组、链表、树、栈、队列、散列表、集合、映射表等,可以分为序列式(sequence) 和关联式(associative)两...
  • 前面提到,无论是向现有 vector 容器中访问元素、添加元素还是插入元素,都只能借助 vector 模板类提供的成员函数,但删除 vector 容器的元素例外,完成此操作除了可以借助本身提供的成员函数,还可以借助一些全局...
  • c++ stl vector扩容机制

    2021-09-02 21:13:13
    vector> using namespace std; int main() { std::vector<int> vec; size_t cap = vec.capacity(); for (int i = 0; i < 10000; i++) { vec.push_back(i); if (cap != vec.capacity()) .
  • 一、vector 的初始化:可以有五种方式 ①vector<type>a(10); 定义10个元素的数组 ②vector<type>a(10,1) 十个元素为1的数组; ③vector a(b); //用b向量来创建a向量,整体复制性赋值 ④vector a(b.begin...
  • STL vector和迭代器

    2021-04-09 14:20:07
    什么是vectorvector是C++标准库类型,它可以容纳一些对象,是一种容器。vector具有数组和链表的一些特征;但和数组不同的是,vector的容量不是恒定不变的,其容量可以高效增长,因此可以不用像数组一样声明初始...
  • 要解释为什么要两倍扩容我们可以分两步理解?... vector的内存空间只增不减,vector内存的回收只能靠vector调用析构函数的时候才被系统收回,当然也可以使用swap来帮你释放内存,具体方法: vec.swap(vec);

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,707
精华内容 41,082
关键字:

stlvector