精华内容
下载资源
问答
  • C语言 --之---vector头文件

    千次阅读 2018-12-04 17:30:40
    vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的. 1. 用法:  1.文件包含:   首先在程序...

                                                   I get it!!!

    vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.


    1. 用法:

              1.文件包含:     

               首先在程序开头处加上#include<vector>以包含所需要的类文件vector

              还有一定要加上using namespace std;

    2. 变量声明:

                   2.1 例:声明一个int向量以替代一维的数组:vector <int> a;(等于声明了一个int数组a[],大小没有指定,可以动态的向里面添加删除)。

                   2.2 例:用vector代替二维数组.其实只要声明一个一维数组向量即可,而一个数组的名字其实代表的是它的首地址,所以只要声明一个地址的向量即可,即:vector <int *> a.同理想用向量代替三维数组也是一样,vector <int**>a;再往上面依此类推.

    3.具体的用法以及函数调用:

              3.1 如何得到向量中的元素?其用法和数组一样:

              例如:

              vector <int *> a

              int b = 5;

              a.push_back(b);//该函数下面有详解

              cout<<a[0];       //输出结果为5

    1.push_back   在数组的最后添加一个数据
    2.pop_back    去掉数组的最后一个数据 
    3.at                得到编号位置的数据
    4.begin           得到数组头的指针
    5.end             得到数组的最后一个单元+1的指针
    6.front        得到数组头的引用
    7.back            得到数组的最后一个单元的引用
    8.max_size     得到vector最大可以是多大
    9.capacity       当前vector分配的大小
    10.size           当前使用数据的大小
    11.resize         改变当前使用数据的大小,如果它比当前使用的大,者填充默认值
    12.reserve      改变当前vecotr所分配空间的大小
    13.erase         删除指针指向的数据项
    14.clear          清空当前的vector
    15.rbegin        将vector反转后的开始指针返回(其实就是原来的end-1)
    16.rend          将vector反转构的结束指针返回(其实就是原来的begin-1)
    17.empty        判断vector是否为空
    18.swap         与另一个vector交换数据

    3.2  详细的函数实现功能:其中vector<int> c.

                                 c.clear()         移除容器中所有数据。

                                 c.empty()         判断容器是否为空。

                                 c.erase(pos)        删除pos位置的数据

                                 c.erase(beg,end) 删除[beg,end)区间的数据

                                 c.front()         传回第一个数据。

                                 c.insert(pos,elem)  在pos位置插入一个elem拷贝

                                 c.pop_back()     删除最后一个数据。

                                 c.push_back(elem) 在尾部加入一个数据。

                                 c.resize(num)     重新设置该容器的大小

                                 c.size()         回容器中实际数据的个数。

                                 c.begin()           返回指向容器第一个元素的迭代器

                                 c.end()             返回指向容器最后一个元素的迭代器

    4.内存管理与效率

          1》使用reserve()函数提前设定容量大小,避免多次容量扩充操作导致效率低下。

            关于STL容器,最令人称赞的特性之一就是是只要不超过它们的最大大小,它们就可以自动增长到足以容纳你放进去的数据。(要知道这个最大值,只要调用名叫max_size的成员函数。)对于vector和string,如果需要更多空间,就以类似realloc的思想来增长大小。vector容器支持随机访问,因此为了提高效率,它内部使用动态数组的方式实现的。在通过 reserve() 来申请特定大小的时候总是按指数边界来增大其内部缓冲区。当进行insert或push_back等增加元素的操作时,如果此时动态数组的内存不够用,就要动态的重新分配当前大小的1.5~2倍的新内存区,再把原数组的内容复制过去。所以,在一般情况下,其访问速度同一般数组,只有在重新分配发生时,其性能才会下降。正如上面的代码告诉你的那样。而进行pop_back操作时,capacity并不会因为vector容器里的元素减少而有所下降,还会维持操作之前的大小。对于vector容器来说,如果有大量的数据需要进行push_back,应当使用reserve()函数提前设定其容量大小,否则会出现许多次容量扩充操作,导致效率低下。

          reserve成员函数允许你最小化必须进行的重新分配的次数,因而可以避免真分配的开销和迭代器/指针/引用失效。但在我解释reserve为什么可以那么做之前,让我简要介绍有时候令人困惑的四个相关成员函数。在标准容器中,只有vector和string提供了所有这些函数。

    (1) size()告诉你容器中有多少元素。它没有告诉你容器为它容纳的元素分配了多少内存。 
    (2) capacity()告诉你容器在它已经分配的内存中可以容纳多少元素。那是容器在那块内存中总共可以容纳多少元素,而不是还可以容纳多少元素。如果你想知道一个vector或string中有多少没有被占用的内存,你必须从capacity()中减去size()。如果size和capacity返回同样的值,容器中就没有剩余空间了,而下一次插入(通过insert或push_back等)会引发上面的重新分配步骤。
    (3) resize(Container::size_type n)强制把容器改为容纳n个元素。调用resize之后,size将会返回n。如果n小于当前大小,容器尾部的元素会被销毁。如果n大于当前大小,新默认构造的元素会添加到容器尾部。如果n大于当前容量,在元素加入之前会发生重新分配。
    (4) reserve(Container::size_type n)强制容器把它的容量改为至少n,提供的n不小于当前大小。这一般强迫进行一次重新分配,因为容量需要增加。(如果n小于当前容量,vector忽略它,这个调用什么都不做,string可能把它的容量减少为size()和n中大的数,但string的大小没有改变。在我的经验中,使用reserve来从一个string中修整多余容量一般不如使用“交换技巧”,那是条款17的主题。)

         这个简介表示了只要有元素需要插入而且容器的容量不足时就会发生重新分配(包括它们维护的原始内存分配和回收,对象的拷贝和析构和迭代器、指针和引用的失效)。所以,避免重新分配的关键是使用reserve尽快把容器的容量设置为足够大,最好在容器被构造之后立刻进行。

    例如,假定你想建立一个容纳1-1000值的vector<int>。没有使用reserve,你可以像这样来做:

    vector<int> v;
    for (int i = 1; i <= 1000; ++i) v.push_back(i);
    在大多数STL实现中,这段代码在循环过程中将会导致2到10次重新分配。(10这个数没什么奇怪的。记住vector在重新分配发生时一般把容量翻倍,而1000约等于210。)

    把代码改为使用reserve,我们得到这个:

    vector<int> v;
    v.reserve(1000);
    for (int i = 1; i <= 1000; ++i) v.push_back(i);
    这在循环中不会发生重新分配。

    在大小和容量之间的关系让我们可以预言什么时候插入将引起vector或string执行重新分配,而且,可以预言什么时候插入会使指向容器中的迭代器、指针和引用失效。例如,给出这段代码,

    string s;
    ...
    if (s.size() < s.capacity()) {
    s.push_back('x');
    }
    push_back的调用不会使指向这个string中的迭代器、指针或引用失效,因为string的容量保证大于它的大小。如果不是执行push_back,代码在string的任意位置进行一个insert,我们仍然可以保证在插入期间没有发生重新分配,但是,与伴随string插入时迭代器失效的一般规则一致,所有从插入位置到string结尾的迭代器/指针/引用将失效。

    回到本条款的主旨,通常有两情况使用reserve来避免不必要的重新分配。第一个可用的情况是当你确切或者大约知道有多少元素将最后出现在容器中。那样的话,就像上面的vector代码,你只是提前reserve适当数量的空间。第二种情况是保留你可能需要的最大的空间,然后,一旦你添加完全部数据,修整掉任何多余的容量。

           2》使用“交换技巧”来修整vector过剩空间/内存

          有一种方法来把它从曾经最大的容量减少到它现在需要的容量。这样减少容量的方法常常被称为“收缩到合适(shrink to fit)”。该方法只需一条语句:vector<int>(ivec).swap(ivec);
    表达式vector<int>(ivec)建立一个临时vector,它是ivec的一份拷贝:vector的拷贝构造函数做了这个工作。但是,vector的拷贝构造函数只分配拷贝的元素需要的内存,所以这个临时vector没有多余的容量。然后我们让临时vector和ivec交换数据,这时我们完成了,ivec只有临时变量的修整过的容量,而这个临时变量则持有了曾经在ivec中的没用到的过剩容量。在这里(这个语句结尾),临时vector被销毁,因此释放了以前ivec使用的内存,收缩到合适。

         3》用swap方法强行释放STL Vector所占内存

    template < class T> void ClearVector( vector<T>& v )

        vector<T>vtTemp;
        vtTemp.swap( v );

    如 
        vector<int> v ;
        nums.push_back(1);
        nums.push_back(3);
        nums.push_back(2);
        nums.push_back(4);
        vector<int>().swap(v);

    /* 或者v.swap(vector<int>()); */

    /*或者{ std::vector<int> tmp = v;   v.swap(tmp);   }; //加大括号{ }是让tmp退出{ }时自动析构*/

     

    5.Vector 内存管理成员函数的行为测试

           C++ STL的vector使用非常广泛,但是对其内存的管理模型一直有多种猜测,下面用实例代码测试来了解其内存管理方式,测试代码如下:

    #include <iostream>
    #include <vector>
    using namespace std;

    int main()
    {
    vector<int> iVec;
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //1个元素, 容器容量为1

    iVec.push_back(1);
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //2个元素, 容器容量为2

    iVec.push_back(2);
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //3个元素, 容器容量为4

    iVec.push_back(3);
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //4个元素, 容器容量为4

    iVec.push_back(4);
    iVec.push_back(5);
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //5个元素, 容器容量为8

    iVec.push_back(6);
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //6个元素, 容器容量为8

    iVec.push_back(7);
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //7个元素, 容器容量为8

    iVec.push_back(8);
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //8个元素, 容器容量为8

    iVec.push_back(9);
    cout << "容器 大小为: " << iVec.size() << endl;
    cout << "容器 容量为: " << iVec.capacity() << endl; //9个元素, 容器容量为16
    /* vs2005/8 容量增长不是翻倍的,如 
        9个元素   容量9 
        10个元素 容量13 */

    /* 测试effective stl中的特殊的交换 swap() */
    cout << "当前vector 的大小为: " << iVec.size() << endl;
    cout << "当前vector 的容量为: " << iVec.capacity() << endl;
    vector<int>(iVec).swap(iVec);

    cout << "临时的vector<int>对象 的大小为: " << (vector<int>(iVec)).size() << endl;
    cout << "临时的vector<int>对象 的容量为: " << (vector<int>(iVec)).capacity() << endl;
    cout << "交换后,当前vector 的大小为: " << iVec.size() << endl;
    cout << "交换后,当前vector 的容量为: " << iVec.capacity() << endl;

    return 0;
    }

    6.vector的其他成员函数

            c.assign(beg,end):将[beg; end)区间中的数据赋值给c。
            c.assign(n,elem):将n个elem的拷贝赋值给c。 
            c.at(idx):传回索引idx所指的数据,如果idx越界,抛出out_of_range。 
            c.back():传回最后一个数据,不检查这个数据是否存在。
            c.front():传回地一个数据。 
            get_allocator:使用构造函数返回一个拷贝。 
            c.rbegin():传回一个逆向队列的第一个数据。 
            c.rend():传回一个逆向队列的最后一个数据的下一个位置。 
            c.~ vector <Elem>():销毁所有数据,释放内存。    

    7.备注:在用vector的过程中的一些问题,特此列出讨论:

                   1)

                        vector <int > a;

                        int  b = 5;

                        a.push_back(b);

                        此时若对b另外赋值时不会影响a[0]的值

                    2)

                        vector <int*> a;
                         int *b;
                         b= new int[4];
                         b[0]=0;
                         b[1]=1;
                         b[2]=2;
                         a.push_back(b);
                         delete b;          //释放b的地址空间
                         for(int i=0 ; i <3 ; i++)
                         {
                               cout<<a[0][i]<<endl;
                         }

                         此时输出的值并不是一开始b数组初始化的值,而是一些无法预计的值.

                        分析:根据1) 2)的结果,可以想到,在1)中,  往a向量中压入的是b的值,即a[0]=b,此时a[0]和b是存储在两个不同的地址中的.因此改变b的值不会影响a[0];而在2)中,因为是把一个地址(指针)压入向量a,即a[0]=b,因此释放了b的地址也就释放了a[0]的地址,因此a[0]数组中存放的数值也就不得而知了.   
    --------------------- 
    作者:hancunai0017 
    来源:CSDN 
    原文:https://blog.csdn.net/hancunai0017/article/details/7032383 

    展开全文
  • C++ 头文件系列(vector)

    千次阅读 2017-01-28 15:48:04
    vector头文件包含vector的类模版以及该模版的显示特化版本vectorvector是C++容器库中非常通用的一种容器,如果你不知道该决定使用哪一种容器,或者没有足够的理由使用其它容器,那么就用它,没错的! 从整体上...

    简介

    vector头文件包含vector的类模版以及该模版的显示特化版本vector< bool >

    vector是C++容器库中非常通用的一种容器,如果你不知道该决定使用哪一种容器,或者没有足够的理由使用其它容器,那么就用它,没错的!

    从整体上来看,vector就像是一种动态数组,它拥有数组的所有功能并且能够动态增长。 它主要有以下性质:

    • 序列性容器
    • 动态增长
    • 可定制的内存分配策略

    内存分配器

    如果在一些特殊的应用场景中,默认的内存分配策略拉低了运行效率,这时候自定义的内存分配其就会站出来帮你了~

    内存分配器主要用在STL Containers中,为容器合理的分配内存,默认使用位于memory头文件中的allocator。 我们也可以自定义内存分配器,但需要满足一些要求:

    Other allocators may be defined. Any class Alloc for which allocator_traits

    上面这段摘录的文字表明,任何能够实例化allocator_traits模版并且带有合适成员函数的类Alloc都能作为容器的内存分配器使用。 再来看allocator_traits:

    The non-specialized version provides an interface that allows to use as allocator just any class that provides at least a public member type value_type and public member functions allocate and deallocate (see example).

    这段话说,任何至少提供了一个公开成员类型value_type和公开成员函数allocate和deallocate的类都可以被允许作为内存分配器

    总的来说,自定义一个内存分配器,你最少需要

    1. 定义value_type类型
    2. 定义allocate成员函数
    3. 定义deallocate成员函数

    特殊函数

    由于vector是动态数组,它的大部分设计是与array类模版类似的,这里就不再赘述了。 我们来看看那些不一样的的地方。

    resize VS shrink_to_fit

    这两个函数是比较特别的,从字面上看它们都是改变大小为固定值。 但实际上两者是有区别的,我们来看它们的函数原型:

    void resize (size_type n);
    void shrink_to_fit ();

    一眼就能看出,两者的参数不一样:resize传入一个数值,作为新的容器大小;而shrink_to_fit则没有参数。 那我们不禁要问了,既然shrink_to_fit没有指定新的容器大小,它怎么改变呢?

    这就揭示了两者语义上的不同----一个是改变大小至给定值,另一个是缩小容器容量(capacity)至容器大小(size)。 也就是说,它们影响的是容器的两个不同方面。 同时需要指出的是, shrink_to_fit调用发出的是请求,调用后容器容量可能被按预期缩小到容器大小了,也有可能比容器大小大;而resize调用发出的时命令,容器一定会被重新调整大小至给定值。

    C接口

    vector提供了一个接口以供开发者直接在内部数组(vector内部以数组实现)上直接对元素进行操作:

    • value_type* data() noexcept;

    顺道一提,vector与array一样,是元素之间的内存连续的(contiguous)。

    vector< bool >显示特化

    非常有意思的是vector

    为什么

    为什么会出现这样一个特殊的模版特化呢? 因为语言支持的最小单位一般是字节(char、unsigned char),而bool的语义意味着它只需要1bit的内存。 如果用1个字节来存储bool类型,会造成极大的内存浪费,出于内存的优化考虑,就出现了这么一个特殊的东西。

    它的原理非常简单,就是把每个bool用1个bit来存储,所以1个字节可以存储8个bool(在常见的机器上)。 但是这也引出了一个麻烦的问题:在语义上,我们应该可以对bool赋值、取地址、取引用等。 但是bool等于bit这种实现方式意味着我们不能够那样做。 那怎么办了,这里使用了一个C++典型的惯用法----代理(Proxy),它把reference成员理性定义为该代理,用这个代理来将内部bit转换成bool。

    Flip函数

    该模版特化还包含了一个额外的函数----Flip。 顾名思义,就是将所有bool都“翻转”,true -> false, false -> true。

    先前提到的reference代理也有这个函数,但它是将单个bool“翻转”。 vector< bool >类模版的flip函数可能就是通过该函数实现的。

    展开全文
  • C++ 头文件系列(vector)_0

    千次阅读 2017-01-28 15:53:10
    vector头文件包含vector的类模版以及该模版的显示特化版本vectorvector是C++容器库中非常通用的一种容器,如果你不知道该决定使用哪一种容器,或者没有足够的理由使用其它容器,那么就用它,没错的! 从整体上...

    简介

    vector头文件包含vector的类模版以及该模版的显示特化版本vector< bool >

    vector是C++容器库中非常通用的一种容器,如果你不知道该决定使用哪一种容器,或者没有足够的理由使用其它容器,那么就用它,没错的!

    从整体上来看,vector就像是一种动态数组,它拥有数组的所有功能并且能够动态增长。 它主要有以下性质:

    • 序列性容器
    • 动态增长
    • 可定制的内存分配策略

    内存分配器

    如果在一些特殊的应用场景中,默认的内存分配策略拉低了运行效率,这时候自定义的内存分配其就会站出来帮你了~

    内存分配器主要用在STL Containers中,为容器合理的分配内存,默认使用位于memory头文件中的allocator。 我们也可以自定义内存分配器,但需要满足一些要求:

    Other allocators may be defined. Any class Alloc for which allocator_traits

    上面这段摘录的文字表明,任何能够实例化allocator_traits模版并且带有合适成员函数的类Alloc都能作为容器的内存分配器使用。 再来看allocator_traits:

    The non-specialized version provides an interface that allows to use as allocator just any class that provides at least a public member type value_type and public member functions allocate and deallocate (see example).

    这段话说,任何至少提供了一个公开成员类型value_type和公开成员函数allocate和deallocate的类都可以被允许作为内存分配器

    总的来说,自定义一个内存分配器,你最少需要

    1. 定义value_type类型
    2. 定义allocate成员函数
    3. 定义deallocate成员函数

    特殊函数

    由于vector是动态数组,它的大部分设计是与array类模版类似的,这里就不再赘述了。 我们来看看那些不一样的的地方。

    resize VS shrink_to_fit

    这两个函数是比较特别的,从字面上看它们都是改变大小为固定值。 但实际上两者是有区别的,我们来看它们的函数原型:

    void resize (size_type n);
    void shrink_to_fit ();

    一眼就能看出,两者的参数不一样:resize传入一个数值,作为新的容器大小;而shrink_to_fit则没有参数。 那我们不禁要问了,既然shrink_to_fit没有指定新的容器大小,它怎么改变呢?

    这就揭示了两者语义上的不同----一个是改变大小至给定值,另一个是缩小容器容量(capacity)至容器大小(size)。 也就是说,它们影响的是容器的两个不同方面。 同时需要指出的是, shrink_to_fit调用发出的是请求,调用后容器容量可能被按预期缩小到容器大小了,也有可能比容器大小大;而resize调用发出的时命令,容器一定会被重新调整大小至给定值。

    C接口

    vector提供了一个接口以供开发者直接在内部数组(vector内部以数组实现)上直接对元素进行操作:

    • value_type* data() noexcept;

    顺道一提,vector与array一样,是元素之间的内存连续的(contiguous)。

    vector< bool >显示特化

    非常有意思的是vector

    为什么

    为什么会出现这样一个特殊的模版特化呢? 因为语言支持的最小单位一般是字节(char、unsigned char),而bool的语义意味着它只需要1bit的内存。 如果用1个字节来存储bool类型,会造成极大的内存浪费,出于内存的优化考虑,就出现了这么一个特殊的东西。

    它的原理非常简单,就是把每个bool用1个bit来存储,所以1个字节可以存储8个bool(在常见的机器上)。 但是这也引出了一个麻烦的问题:在语义上,我们应该可以对bool赋值、取地址、取引用等。 但是bool等于bit这种实现方式意味着我们不能够那样做。 那怎么办了,这里使用了一个C++典型的惯用法----代理(Proxy),它把reference成员理性定义为该代理,用这个代理来将内部bit转换成bool。

    Flip函数

    该模版特化还包含了一个额外的函数----Flip。 顾名思义,就是将所有bool都“翻转”,true -> false, false -> true。

    先前提到的reference代理也有这个函数,但它是将单个bool“翻转”。 vector< bool >类模版的flip函数可能就是通过该函数实现的。

    展开全文
  • c++头文件Vector(Vector的用法)

    千次阅读 2021-03-08 17:34:19
    c++头文件Vector 开始学习c++,再这个过程中第一个令人头疼的地方就是头文件的含义了,c++头文件的内容会随着我的深入学习进行更新. 首先,我们需要该清楚Vector的定义: C++标准库提供了被封装的动态数组——Vector。...

    c++头文件之Vector

    开始学习c++,再这个过程中第一个令人头疼的地方就是头文件的含义了,c++头文件的内容会随着我的深入学习进行更新.
    首先,我们需要该清楚Vector的定义: C++标准库提供了被封装的动态数组——Vector。大体上讲,就是更容易上手的动态数组.让我们看看Vector的优缺点.
    优点:
    1). Vector可以存放任意类型的数据
    2). 容量可以自动扩展
    3). 初始化形式简单,多样
    4). 可以插入或删除元素
    5). 可以获取数组的长度(是否为空)
    6). 也是通过下标来访问的
    7). 能够一下清除所有数据
    8). 强制调整数组元素的个数以及数值
    9). 将数组的容量进行人为的扩大
    10). 将两个Vector数组的值进行整体性交换

    缺点: Vector的操作简单,容易上手,是数组的"升级版",但是Vector的每次自动扩容都是增加当前空间的50%(第一次除外);会消耗大量的空间与时间,所以小数据使用Vector还是很高效的.

    使用步骤:

    (1) 加入头文件

    代码如下(示例):

    #include<vector>
    
    using namespace std;
    

    (2) Vector数组的初始化

    代码如下(示例):

    //1. 直接赋值
       vector <int> A1 {1,2,3,4,5};               //一维
       vector <vector <int>> A2 {{1,2,3},{1,2,3}};//二维
       
    //2. 不带参数构造
       vector <int> A1;//空的数组,长度为0(size()为0)可以用push_back(elem)输入元素
       
    //3. 带参数构造
       vector <int> A2(10);  //10个数据全为0
       vector <int> A3(10,1);//10个数据全为1
       
    //4. 通过同类型的vector初始化
       vector <int> A1(5,1);
       vector <int> A2(A1);  //通过A1来初始化A2
    

    (3) 访问

    3.1 通过地址访问

    代码如下(示例):

       ///通过地址访问
       vector<int> A1 {1,2,3,4,5};        //一维
       vector<int>::iterator k=A1.begin();//返回第一个元素的地址
       cout<<*k<<endl;     //输出1
       cout<<*(k+1)<<endl; //输出2
       vector<int>::iterator k=A1.end();  //返回最后一个元素的下一位地址
       cout<<*(k-1)<<endl; //输出5
       
    

    3.2 通过下标访问

    代码如下(示例):

     ///通过下标访问
       vector<int> A1 {1,2,3,4,5}; //一维
       cout<<A1.at(0)<<endl;       //输出为1
       
    

    (4) 增,删

    4.1 插入,删除(栈顶)

    代码如下(示例):

     ///添加,删除
       A.pop_back();      //删除最后一个元素
       A.push_back(elem); //在尾部添加一个元素
    

    4.2 特定位置插入删除

    代码如下(示例):

    ///特定位置插入删除
       vector<int> A1 {1,2,3,4,5};        //一维
       vector<int>::iterator k=A1.begin();//下标从0开始
       A1.insert(k+1,9);                  //A1={1,9,2,3,4,5}
       A1.erase(k+1);                     //A1={1,3,4,5}
    

    (5) 获取数组的长度

    代码如下(示例):

    ///获取长度或者判断数组是否为空
       vector<int> A1 {1,2,3,4,5};//一维
       cout<<A1.size()<<endl;//输出5
       cout<<A1.empty()<<endl;//输出0
    

    (6) 其他用法

    代码如下(示例):

    ///返回可用总元素
        A.capacity(); //返回A在内存中总共可以容纳的元素个数
        
    ///强制调整元素个数以及数值    
        A.resize(10); //将A的现有元素个数调至10个,多则删,少则补,其值随机    
        A.resize(10,2); //将A的现有元素个数调至10个,多则删,少则补,其值为2
        
    ///将数组扩容    
        A.reserve(100); //将A的容量(capacity)扩充至100,也就是说现在测试A.capacity();的时候返回值是100.这种操作只有在需要给A添加大量数据的时候才         显得有意义,因为这将避免内存多次容量扩充操作(当A的容量不足时电脑会自动扩容,当然这必然降低性能) 
        
    ///将Vector数组A,B的元素进行整体交换   
        A.swap(B); //B为向量,将A中的元素和B中的元素进行整体性交换
    
    

    (7)几种重要的算法,使用时需要包含头文件:

    #include < algorithm >

    代码如下(示例):

    #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,若存在返回其在向量中的位置
      
    
    展开全文
  • vector函数总结

    万次阅读 多人点赞 2018-09-04 10:17:52
    ((1)头文件#include&amp;lt; vector &amp;gt;. (2)创建vector对象,vector&amp;lt; int &amp;gt; vec; (3)尾部插入数字:vec.push_back(a); (4)使用下标访问元素,cout&amp;lt;&amp;lt; ...
  • - sort 函数 ...首先头文件:#include 【在c++里要多加一个 using namespace std; 】 1、 没有第三个参数,默认从小到大排序 #include<bits/stdc++.h> using namespace std; int A[10]={2,5,1,8,20,12
  • c++ vector基本函数、排序、查找用法

    万次阅读 多人点赞 2019-07-31 19:51:25
    vector用法目录: ...5、find()函数的用法 6、vector实战(这里写的是我在最开始用vector时候犯的错误) 1、基本用法: 头文件: #include<vector> 定义vector: 整数型: vector<int>...
  • 使用vector头文件定义与数据读取

    千次阅读 2009-01-12 15:09:00
    #include #include #include using namespace std; //空间命名 //Vector数组读取 vector::iterator p_iter; FIELDDEF_DATATYPE DataType; for(p_iter = FieldDef.begin(); p_iter != FieldDef.end(); p
  • 头文件是#include reverse函数用于反转在[first,last)范围内的顺序(包括first指向的元素,不包括last指向的元素), reverse函数无返回值 例如: string str="hello world , hi"; reverse(str.begin(),str.end());...
  • c++头文件函数

    2020-02-26 16:42:29
    1、#include<iostream> system(“pause”): 系统暂停 system(“mode con cols=a lines=b”): 设置控制台屏幕大小 system(“cls”): 清屏 2、#include <...sqrt(): 开方函数,参数为要开方数据,返回d...
  • C/C++常用头文件函数汇总

    千次阅读 2019-03-23 20:32:49
    C/C++头文件一览 C #include <assert.h> //设定插入点 #include <ctype.h> //字符处理 #include <errno.h> //定义错误码 #include <float.h> //浮点数处理 #include <iso646.h>...
  • vector函数的使用

    2016-07-20 11:50:36
    vector函数的使用
  • 使用前记得引入头文件 #include <algorithm> 用法 反转 vector vector<int> a = {1,2,3,4,5}; reverse(a.begin(),a.end());//a的值为5,4,3,2,1 反转 string string str="12345"; reverse(str....
  • C++_vector操作

    万次阅读 多人点赞 2019-05-28 11:24:15
    vector头文件-vector vector初始化: 方式1. vector<int>a(10);//定义具有10个整型元素的向量(尖括号为元素类型名,它可以是任何合法的数据类型),不具有初值,其值不确定 方式2. vector<int>...
  • C++头文件algorithm的find 函数

    千次阅读 2018-11-24 23:21:23
    很多语言都内置了非常方便的查找函数方便我们调用,其实C++中也有find函数vector中 使用find()函数需要#include&lt;algorithm&gt;,例如: vector&lt;string&gt; ar1; ar1.push_back("...
  • c++各个头文件所包含常用函数

    千次阅读 多人点赞 2018-10-30 16:42:11
    c++各个头文件所包含常用函数 目录: 1.&lt;cstdlib&gt; 2.&lt;cctype&gt; 3.&lt;cstring&gt; 4.&lt;cmath&gt; 5.&lt;string&gt; 6.&lt;algorithm&gt; 7.&...
  • C++algorithm头文件下sort函数的使用

    万次阅读 多人点赞 2019-07-05 11:24:10
    1. sort函数是用来排序的函数,它是根据具体的情况使用不同的排序方法,效率较高,一般来说,不推荐使用C语言中的qsort函数,原因是qsort函数使用起来比较麻烦,涉及到很多指针的操作,而且在sort函数在实现中规避了...
  • 这篇文章主要介绍了c++中,vector是一个十分有用的容器,下面对这个容器做一下总结 ...c++ vector用法 ...C++内置的数组支持容器的机制,但是它...标准库vector类型使用需要的头文件:#include 。vector 是一个类模
  • vector 详细用法 C++

    万次阅读 多人点赞 2016-04-11 20:54:48
    如果希望深刻理解vector的这些个成员函数,最好的办法是详细了解其内部实现,《STL源码解析》是个好途径!当然,也可以 直接看编译器自带的的源码。 vector是C++标准模板库中的部分内容,vector之所以被认为
  • 就可以写这样一个比较函数 以下是代码片段 bool cmp(node x,node y)  {  if(x.a!=y.a) return x.a  if(x.b!=y.b) return x.b>y.b;  return return x.c>y.c;  }  排序时写 sort(arr,a+100,...
  • C++STL中string的头文件中的常用函数

    千次阅读 2020-03-02 22:30:29
    文章目录STL简介头文件初始化操作实现效果基本函数1.size,length,capacity2.resize,reserve1,2的实现代码实现效果3.at,append,insert4.empty,compare,copy,find,replace5.substr,swap,erase,assign ...
  • vector函数

    2019-02-26 09:38:19
    原文:https://blog.csdn.net/qq_36386435/article/details/82379261  原文:...   基本操作  ((1)头文件#include&lt; vector &gt;.  (2)创建vector对象,vector&lt; int ...
  • C++里vector::erase函数

    万次阅读 多人点赞 2017-06-03 11:07:33
    vector::erase():从指定容器删除指定位置的元素或某段范围内的元素  vector::erase()方法有两种重载形式  如下:  iterator erase( iterator _Where);  iterator erase( iterator _First, iterator _Last);...
  • C++编程常用头文件及其包含函数汇总

    千次阅读 多人点赞 2018-03-31 16:23:23
    C++编程常用头文件及其包含函数汇总1、#include &lt;iostream&gt;#include&lt;iostream&gt;是标准的C++头文件,任何符合标准的C++开发环境都有这个头文件。当使用&lt;iostream.h&gt;时,...
  • C++ vector容器和sort函数的学习

    万次阅读 2018-05-22 15:19:18
    Vector注意事项: 声明形如vector&lt;&gt; vec;的不是new出来而是作为普通变量的那么不需要delete, 在变量超出作用域时会自动回收 如果是用*vec = new vector&lt;&gt;()这种方式动态创建的vector...
  • C++—— vector用法(详解!!函数,实现)

    千次阅读 多人点赞 2019-11-11 21:02:11
    vector 是C++ STL的一个重要成员,使用它时需要包含头文件: #include<vector>; 一、vector 的初始化:可以有五种方式,举例说明如下: (1) vector<int> a(10); //定义了10个整型元素...
  • C++ vector常用函数总结

    2020-03-02 17:04:39
    向量(Vector)是一个封装了动态大小数组的顺序容器,能够存放各种类型的对象。可以简单的认为,向量是一个能够存放任意类型的动态数组。 二.常用函数 1.增加函数 void push_back(const T& x):向量尾部增加一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,771
精华内容 21,508
关键字:

vector函数的头文件