精华内容
下载资源
问答
  • c++中vector用法详解

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

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

             变量声明:

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

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

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

                  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交换数据

            详细的函数实现功能:其中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()             返回指向容器最后一个元素的迭代器

     

     

    展开全文
  • C++中vector用法详解

    千次阅读 2016-09-20 23:02:18
    vector作为STL提供的标准容器之一,是经常要使用的,有很重要的地位,并且使用起来也是灰常方便。vector又被称为向量,vector可以形象的描述为长度可以动态改变的数组,功能和数组较为相似。实际上更专业的描述为:...

    1.vector的简单介绍

    vector作为STL提供的标准容器之一,是经常要使用的,有很重要的地位,并且使用起来也是灰常方便。vector又被称为向量,vector可以形象的描述为长度可以动态改变的数组,功能和数组较为相似。实际上更专业的描述为:vector是一个多功能的,能够操作多种数据结构和算法的模板类和函数库,vector之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据。(注:STL的容器从实现的角度讲可以说是类模板(class teplate)。)

    那么vector和数组的主要区别是什么呢??这对于理解vector是很有帮助的~~~~

    数组:分配的是静态空间,一般分配了就不可以改变,就像我们熟知的定义了一个数组,那么数组的长度就不可以改变了,我们也不可以进行越界访问,但是编译器不检查越界,这一点在我们编程的时候要尤为注意(很多都可能会烦这样的错误!!)。一般申请的数组长度不能满足我们的要求了,我们要重新申请大一点数组,然后把原数组中数据复制过来。

    vector:分配的是动态空间,即:我们发现在声明vector容器的时候也可以不指定容器的大小,vector是随着元素的加入,空间自动扩展的。但是,我们必须要负责任的肯定vector分配的空间是连续的,也就是支持数组中的下标随机访问,实际上vector的实现机制是:预留一部分空间,而且预留空间的大小是按一定比率增长的,如果空间不够用的话,要保证连续,就必须重新new一片空间,然后将原有元素移动到新空间,同时预留新的空间(并且新分配的空间比原来分配的空间),最后将原来的那部分空间释放掉。这样预留空间的好处就是不用每次向vector中加元素都重新分配空间。

     

    2.vecotr容器中常用的函数

    2.1.vector容器的构造函数

    vector容器的声明方式主要包括一下几种:


    vector<Elem> v   ,创建一个空的vector。

    vector <Elem> v1(v)   ,复制一个vector。

    vector <Elem> v(n)  ,创建一个vector,含有n个数据,数据均已缺省构造产生。

    vector <Elem> v(n, elem)   ,创建一个含有n个elem拷贝的vector。

    vector <Elem> v(beg,end)   ,创建一个以[beg;end)区间的vector。

    v.~ vector <Elem>()  ,销毁所有数据,释放内存。


    下面用一段代码来演示几种常用的声明vector的的方式:

    复制代码
     1 #include <iostream>
     2 #include <vector>
     3 
     4 using namespace std;
     5 
     6 int main()
     7 {
     8     vector<int>::iterator iter;
     9     //第一种方式
    10     vector<int> v1;
    11     v1.push_back(1);
    12     v1.push_back(2);
    13     v1.push_back(3);
    14     cout<<"第一种方式的输出结果:"<<endl;
    15     for(iter = v1.begin() ; iter != v1.end() ; iter++)
    16     {
    17         cout<<*iter<<" ";
    18     }
    19     cout<<endl;
    20     //第二种方式
    21     vector<int> v2(v1);
    22     cout<<"第二种方式的输出结果:"<<endl;
    23     for(iter = v2.begin() ; iter != v2.end() ; iter++)
    24     {
    25         cout<<*iter<<" ";
    26     }
    27     cout<<endl;
    28     //第三种方式
    29     vector<int> v3(3);
    30     cout<<"第三种方式的输出结果:"<<endl;
    31     for(iter = v3.begin() ; iter != v3.end() ; iter++)
    32     {
    33         cout<<*iter<<" ";
    34     }
    35     cout<<endl;
    36     //第四种方式
    37     vector<int> v4(3,4);
    38     cout<<"第四种方式的输出结果:"<<endl;
    39     for(iter = v4.begin() ; iter != v4.end() ; iter++)
    40     {
    41         cout<<*iter<<" ";
    42     }
    43     cout<<endl;
    44     //第五种方式
    45     vector<int> v5(v1.begin(),v1.end()-1);
    46     cout<<"第五种方式的输出结果:"<<endl;
    47     for(iter = v5.begin() ; iter != v5.end() ; iter++)
    48     {
    49         cout<<*iter<<" ";
    50     }
    51     cout<<endl;
    52     //第六种方式
    53     int a[] = {1,2,3,4};
    54     vector<int> v6(a+1,a+2);
    55     cout<<"第六种方式的输出结果:"<<endl;
    56     for(iter = v6.begin() ; iter != v6.end() ; iter++)
    57     {
    58         cout<<*iter<<" ";
    59     }
    60     cout<<endl;
    61     //
    62     v6.~vector<int>();
    63     cout<<"释放内存后的结果是:"<<endl;
    64     for(iter = v6.begin() ; iter != v6.end() ; iter++)
    65     {
    66         cout<<*iter<<" ";
    67     }
    68     cout<<endl;
    69     return 0;
    70 }
    复制代码

    运行结果:

    小结:注意这种:vector <Elem> c(beg,end)声明方式,创建一个和[beg;end)区间元素相同的vector,一定要注意是左闭右开区间,同时需要说的是,STL中不论是容器还是算法都是采用的这种左闭右开区间办事的,包括v.end()函数也是返回的vector末端的下位置,相当于int a[n]的a[n],并不能访问~~~

    2.2.vector中其他常用的函数用法


    v.assign(beg,end)  , 将[beg; end)区间中的数据赋值给v。

    v.assign(n,elem)    ,  将n个elem的拷贝赋值给v。

    v.at(idx)                ,  传回索引idx所指的数据,如果idx越界,抛出out_of_range。

    v.begin()               ,  传回迭代器重的可一个数据。

    v.capacity()           ,  返回容器中数据个数。

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

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

    v.end()                  ,  指向迭代器中的最后一个数据地址。


    用上面提到的函数写一个程序演练一下吧:

    复制代码
     1 #include <iostream>
     2 #include <vector>
     3 
     4 using namespace std;
     5 
     6 int main()
     7 {
     8     vector<int>::iterator iter;
     9     vector<int>v1;
    10     int a[] = {1,2,3,4};
    11     
    12     //程序段1,练习assign(n,t)
    13     v1.assign(3,2);
    14     cout<<"vector 中的元素:";
    15     for(iter = v1.begin() ; iter != v1.end() ; ++iter)
    16     {
    17         cout<<*iter<<" ";
    18     }
    19     cout<<endl<<endl;
    20     
    21     //程序段2,练习assign(beg,end)
    22     v1.assign(a,a+4);
    23     cout<<"vector 的长度是:"<<v1.capacity()<<endl;
    24     cout<<"vector 中的元素:";
    25     for(int i = 0 ; i < 4 ; ++i)
    26     {
    27         cout<<v1.at(i)<<" ";
    28     }
    29     cout<<endl<<endl;
    30     
    31     //程序段3,练习clear()函数和enpty()函数
    32     v1.clear();
    33     if(v1.empty())
    34     {
    35         cout<<"vector为空!!!"<<endl;
    36     }
    37 
    38     return 0;
    39 }
    复制代码

    运行结果:

    小结:关于assign函数,对vector变量进行赋值,并且能够自动完成vector大小的修改。

     


    v.insert(pos,elem)         在pos位置插入一个elem拷贝,传回新数据位置(位置指传回地址值)。

    v.insert(pos,n,elem)      在pos位置插入在[beg,end)区间的数据。无返回值

    v.insert(pos,beg,end)       在pos位置插入n个elem数据。无返回值

    v.erase(pos)          删除pos位置的数据,传回下一个数据的位置

    v.erase(beg,end)       删除[beg,end)区间的数据,传回下一个数据的位置。


    看看vector中的元素的插入和删除操作吧:

    复制代码
     1 #include <iostream>
     2 #include <vector>
     3 
     4 using namespace std;
     5 
     6 int main()
     7 {
     8     int a[] = {2,3,4};
     9     vector<int> v1;
    10     vector<int>::iterator iter;
    11     
    12     //演示insert函数
    13     v1.insert(0,1);
    14     v1.insert(v1.begin()+1,a,a+3);
    15     v1.insert(v1.begin()+4,2,5);
    16     cout<<"vector中的数据 :";
    17     for(iter = v1.begin() ; iter != v1.end() ; ++iter)
    18     {
    19         cout<<*iter<<" ";
    20     }
    21     cout<<endl<<endl;
    22     //演示erase函数
    23     v1.erase(v1.begin(),v1.begin()+2);
    24     v1.erase(v1.begin()+1);
    25     cout<<"vector中的数据 :";
    26     for(iter = v1.begin() ; iter != v1.end() ; ++iter)
    27     {
    28         cout<<*iter<<" ";
    29     }
    30     cout<<endl<<endl;
    31     return 0;
    32 }
    复制代码

    运行结果:

    小结:注意插入和删除操作的pos参数用迭代器传入的。还要注意几种insert函数的返回值。

     


    v.capacity()      返回容器中数据个数。

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

    v.reserve()     保留适当的容量。 

    v.resize(num)    重新指定队列的长度。

    v.max_size()       返回容器中最大数据的数量。


    复制代码
     1 #include <iostream>
     2 #include <vector>
     3 
     4 using namespace std;
     5 
     6 int main()
     7 {
     8     vector<int> v1(4,1);
     9     vector<int>::iterator iter;
    10     cout<<"vector的size的值 : "<<v1.size()<<endl;
    11     cout<<"vector的capacity值 : "<<v1.capacity()<<endl;
    12     cout<<"vector的max_size的值 : "<<v1.max_size()<<endl;
    13     
    14     //使用reserve函数
    15     v1.reserve(6);
    16     cout<<endl;
    17     cout<<"vector的size的值 : "<<v1.size()<<endl;
    18     cout<<"vector的capacity值 : "<<v1.capacity()<<endl;
    19     cout<<"vector的max_size的值 : "<<v1.max_size()<<endl;
    20     cout<<"vector中的元素是 : ";
    21     for(iter = v1.begin() ; iter != v1.end() ; iter++)
    22     {
    23         cout<<*iter<<" ";
    24     }
    25     cout<<endl<<endl;
    26 
    27     //使用resize函数
    28     v1.resize(6,2);
    29     cout<<endl;
    30     cout<<"vector的size的值 : "<<v1.size()<<endl;
    31     cout<<"vector的capacity值 : "<<v1.capacity()<<endl;
    32     cout<<"vector的max_size的值 : "<<v1.max_size()<<endl;
    33     cout<<"vector中的元素是 : ";
    34     for(iter = v1.begin() ; iter != v1.end() ; iter++)
    35     {
    36         cout<<*iter<<" ";
    37     }
    38     cout<<endl<<endl;
    39     return 0;
    40 }
    复制代码

    输出结果:

    小结:vector 的reserve增加了vector的capacity,但是它的size没有改变!而resize改变了vector的capacity同时也增加了它的size!这是因为:(1)reserve是为容器预留空间,但在空间内不真正创建元素对象,所以在没有添加新的对象之前,不能引用容器内的元素。加入新的元素时,要调用push_back()/insert()函数。(2)resize则是改变容器的大小,且在创建对象,因此,调用这个函数之后,就可以引用容器内的对象了,因此当加入新的元素时,用operator[]操作符,或者用迭代器来引用元素对象。此时再调用push_back()函数,是加在这个新的空间后面的。

     


    c.rbegin()       传回一个逆向队列的第一个数据。

    c.rend()          传回一个逆向队列的最后一个数据的下一个位置。

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

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

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

    c.back()           传回最后一个数据,不检查这个数据是否存在。

    c1.swap(c2)        将c1和c2元素互换。

    swap(c1,c2)        同上操作。

    展开全文
  • c++中vector用法详解

    万次阅读 多人点赞 2018-09-05 13:32:17
    c++中vector用法详解 2011年12月01日 21:25:06 阅读数:414421 标签: vectorc++stringinsert测试数据结构更多 个人分类: c语言  vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态...

    c++中vector的用法详解

    2011年12月01日 21:25:06 阅读数:414421 标签: vectorc++stringinsert测试数据结构更多

    个人分类: c语言

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

         用法:

              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]数组中存放的数值也就不得而知了.   

    展开全文
  • C++ Vector用法详解

    2020-09-03 13:38:53
    主要介绍了C++ Vector用法详解,vector是C++标准模版库(STL,Standard Template Library)的部分内容,本文详细介绍了它的方方面面,需要的朋友可以参考下
  • C++中vector用法详解

    2018-03-10 20:44:14
    c++中vector用法详解 vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的. 1.头文件#include<...
    vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.
    1.头文件#include<vector>.
    2.变量声明:
            2.1 例:声明一个int向量以替代一维的数组:vector <int> a;(等于声明了一个int数组a[],大小没有指定,可以动态的向里面添加删除)。
            2.2 例:用vector代替二维数组.其实只要声明一个一维数组向量即可,而一个数组的名字其实代表的是它的首地址,所以只要声明一个地址的向量即可,即:vector <int *> a.同理想用向量代替三维数组也是一样,vector <int**>a;再往上面依此类推.
     3. 详细的函数实现功能:其中vector<int> ve.
               ve.clear()         清空容器中所有数据。
               ve.empty()         判断容器是否为空。
               ve.erase(pos)        删除pos位置的数据
            ve.erase(beg,end) 删除[beg,end)区间的数据
               ve.front()         传回第一个数据。
    ve.back() 传回最后一个数据,不检查这个数据是否存在
               ve.insert(pos,elem)  在pos位置插入一个elem拷贝
               ve.pop_back()     删除最后一个数据。
               ve.push_back(elem) 在尾部加入一个数据。
               ve.resize(num)     重新设置该容器的大小
               ve.size()         回容器中实际数据的个数。
               ve.begin()           返回指向容器第一个元素的迭代器
              ve.end()             返回指向容器最后一个元素的迭代器
    ve.reserve()     改变当前vecotr所分配空间的大小
    ve.capacity() 容器容量
    ve.at(idx)传回索引idx所指的数据,如果idx越界,抛出out_of_range
    ve.assign(beg,end):将[beg; end)区间中的数据赋值给ve
            ve.assign(n,elem):将n个elem的拷贝赋值给ve
    ve.~ vector <Elem>() 销毁所有数据,释放内存
    4.函数实现举例:
    假定你想建立一个容纳1-1000值的vector<int>
    4.1
    vector<int> v;
    for (int i = 1; i <= 1000; ++i)
    v.push_back(i);
    在大多数STL实现中,这段代码在循环过程中将会导致2到10次重新分配。
    4.2
    vector<int> v;
    v.reserve(1000); //使用reserve()函数提前设定容量大小
    for (int i = 1; i <= 1000; ++i)
    v.push_back(i);
    这在循环中不会发生重新分配。
    4.使用下标访问元素
    cout<<ve[0]<<endl; //记住下标是从0开始的
    5.使用迭代器访问元素
    vector<int>::iterator it; //用来遍历或者指向容器里面的元素
    for(it=ve.begin();it!=ve.end();it++)
    {
    cout<<*it<<endl;
    }
    6.插入和删除元素
     ve.insert(ve.begin()+i,a); 在第i+1个元素前面插入a;
    ve.erase(ve.begin()+2); 删除第3个元素
    ve.erase(ve.begin()+i,ve.end()+j); 删除区间[i,j-1]; 区间从0开始
    展开全文
  • C语言vector使用方法 C++中vector用法详解

    万次阅读 多人点赞 2016-08-27 20:13:05
    vectorC++标准模板库的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放...
  • C++ STL vector 用法详解

    2019-09-27 15:41:39
    vector :将元素置于动态数组加以管理的一个抽象的概念。 所以它的本质应该是一个内存连续的动态数组. #include <vector> namespace std{ template <class T,class Allocator = allocator<T>>...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,206
精华内容 3,682
热门标签
关键字:

c++中vector的用法详解

c++ 订阅