精华内容
下载资源
问答
  • vector容器不但能像数组一样对元素进行随机访问,还能在尾部插入元素,是一种简单,高效的容器,完全可以代替数组vector具有自动管理功能,对于元素的插入和删除,可动态调整所占的内存空间。 vector模版类需要两...

    STL其他内容解析:关于C++中STL的理解和应用


    目录

    vector介绍:

    vector的底层实现:

    vector初始化:

    存取操作:

    vector用迭代器访问:

    其他操作:

    vector作为函数参数传递

    vector作为函数返回值

    vector的排序

    vector在类中使用:

    例题:


    vector介绍:

    vector容器不但能像数组一样对元素进行随机访问,还能在尾部插入元素,是一种简单,高效的容器,完全可以代替数组,vector具有自动管理功能,对于元素的插入和删除,可动态调整所占的内存空间。

    vector模版类需要两个模版参数,第一个参数是存储元素的数据类型,第二个参数是存储分配器的类型,其中第二个参数是可选的,如果不给出第二个参数,将使用默认的分配器。

    使用要加头文件<vector>。

    vector的底层实现

    底层是数组,即将元素保存在一段连续的内存空间中。支持快速随机访问。在尾部之外的位置插入删除元素可能会很慢。

    PS:当元素已经占满了预先分配的内存空间,插入新的元素时,开辟一段新的内存空间,大小为之前vector的两倍,再将vector内的元素拷贝到新的内存空间内。

    vector的插入删除操作会造成迭代器的失效

    vector初始化:

    (1)不带参数的构造函数初始化

    vector<int> a;  //初始化一个size为0的vector

    (2)带参数的构造函数初始化

    //初始化size,但每个元素值为默认值
    vector<int> abc(10);   //初始化了10个默认值为0的元素
    
    //初始化size,并且设置初始值
    vector<int> cde(10,1); //初始化了10个值为1的元素

    (3)通过数组地址初始化

    int a[5] = {1,2,3,4,5}; //通过数组a的地址初始化,注意地址是从0到5(左闭右开区间)
    vector<int> b(a, a+5);

    (4)通过同类型的vector初始化

    vector<int> a(5,1); //通过a初始化
    vector<int> b(a);

    二维vector的初始化: 

    vector<vector<int> > a(n,vector<int>(m,0)); //n行m列的a初始化为0

    存取操作:

    定义: vector<类型> 变量名称。 如 vector<int> s;

    s[i]                    //  直接以下标方式访问容器中的元素
    s.front()            //  返回首元素
    s.back()            //  返回尾元素
    s.push_back(x)      //  向表尾插入元素x
    s.pop_back()     //  删除表尾元素
    s.size()               //  返回vector大小
    s.empty()           //  表为空时,返回真,否则返回假

    vector用迭代器访问:

    s.begin()            //  返回指向首元素的随机存取迭代器
    s.end()              //  返回指向尾元素的下一个位置的随机存取迭代器
    s.insert(it, val)     //  向迭代器it指向的元素前插入新元素val
    s.insert(it, n, val)  //  向迭代器it指向的元素前插入n个新元素val
    s.erase(it)         //  删除由迭代器it所指向的元素   erase函数的返回的是指向被删除元素的下一个元素的迭代器

    其他操作:

    s.reserve(n)      //缓冲空间,使存储空间至少可容纳n个元素
    s.resize(n)         //  改变序列长度,超出的元素将会全部被删除,如果序列需要扩展(原空间小于n),元素默认值将填满扩展出的空间
    s.resize(n, val)    //  改变序列长度,超出的元素将会全部被删除,如果序列需要扩展(原空间小于n),val将填满扩展出的空间
    s.clear()           //  删除容器中的所有元素
    s.swap(v)           //  将s与另一个vector对象进行交换

    //  要注意的是,resize操作和clear操作都是对表的有效元素进行的操作,但并不一定会改变缓冲空间的大小
    //  另外,vector还有其他的一些操作,如反转、取反等,不再一一列举
    //  vector上还定义了序列之间的比较操作运算符(>、<、>=、<=、==、!=),可以按照字典序比较两个序列。

    vector作为函数参数传递

    1.  void func(vector<int> x);     传值,需要调用复制构造函数,形参和实参独立的,速度较慢。
    2. void func(vector<int>* x);    传地址,调用时需要用 x-> 形式,形参和实参一致,速度快,但是使用不习惯,所以更习惯用第三种传引用
    3. void func(vector<int>& x);   传引用,形参实参一致,速度快,更方便。如果不想修改实参,可以加const修饰:void func(const vector<int>& x);

    vector作为函数返回值

    如果返回参数较少,可以不用定义vector,直接用 { } 进行返回。

     vector<int> func(){
        ....
        if () return {l,r}; //返回l,r两个数
            else return {};  //返回空
    }

    vector的排序

    普通的类型

    vector<int>v; 
    
    	sort(v.begin(),v.end(),greater<int>());   //从大到小
    	sort(v.begin(),v.end(),less<int>());      //从小到大

    自定义类型

    struct node{
    	int a;
    	int b;
    };
    vector<node>v;
    
    bool cmp(node x,node y){
    	if(x.a==y.a) return x.b>y.b;
    	return x.a>y.a;
    }
    
    int main(){
    	....
    	sort(v.begin(),v.end(),cmp);
    	....
     } 

    二维vector的排序

    如待排序数组为n*2的,按第二个元素的大小排序

        bool cmp(vector<int> a,vector<int> b){
            if (a[1]>b[1]) return true;
            else return false;
        }
    
        vector<vector<int>> a;
        sort(a.begin(),a.end(),cmp);
    

    自定义排序

    sort()函数,默认的是对二维数组按照第一列的大小对每行的数组进行排序。所以可以加上cmp函数用按照任意列对数组进行排序。 

    【对二维数组排序】
    #include<bits/stdc++.h>
    using namespace std;
    //按照二维数组第一列的大小对每个一维数组升序排序,
    //如何第一列相同时,按照第二列大小对每行的数组降序排序
    bool cmp(vector<int>&a,vector<int>&b){
        if(a[0]!=b[0]) return a[0]<b[0];
        else return a[1]>b[1];
    }
    int main()
    {
        vector<vector<int> >a(6);
        int x;
        for(int i=0;i<6;i++){
            for(int j=0;j<2;j++){
                cin>>x;
                a[i].push_back(x);
            }
        }
        cout<<endl;
        sort(a.begin(),a.end(),cmp);
        for(int i=0;i<6;i++){
            for(int j=0;j<2;j++){
                cout<<a[i][j]<<" ";
            }
            cout<<endl;
        }
        return 0;
    }

    vector在类中使用:

    1.vector在类中定义时,不能直接对其实例化。如下是错误的:

    class student{
    public:
    	
    private:
    	int sum;
    	vector<int> score(10);	
    };
    

    因为编译器认为,score这个vector不属于student这个类,而是属于实例,所以在这里你想定义score的个数是10,是不行的。

    解决办法:在构造函数中,定义vector的大小。如下:

    class student{
    public:
    	student(){
    		score=vector<int> (10);
    	}
    	
    private:
    	int sum;
    	vector<int> score;	
    };

    2.在类中写cmd函数时,需要声明为static。

    因为所有我们在类内定义的非static成员函数在经过编译后隐式的为他们添加了一个this指针参数!变为了:

    bool cmp(Solution *this, int a, int b)
    

    而标准库的sort()函数的第三个cmp函数指针参数中并没有这样this指针参数,因此会出现输入的cmp参数和sort()要求的参数不匹配,从而导致了:
    error: reference to non-static member function must be called
    而我们知道static静态类成员函数是不需要this指针的,因此改为静态成员函数即可通过!

    例题:

    木块问题:UVa101 木块问题 使用vector求解_马小超-CSDN博客

    展开全文
  • C++ vector底层数据结构

    千次阅读 2020-07-17 10:00:01
    底层数据结构是数组,由于数组的特点,vector也具有以下特性: 1、O(1)时间的快速访问; 2、顺序存储,所以插入到非尾结点位置所需时间复杂度为O(n),删除也一样; 3、扩容规则: 当我们新建一个vector的时候,会...

    vector
    其底层数据结构是数组,由于数组的特点,vector也具有以下特性:
    1、O(1)时间的快速访问;
    2、顺序存储,所以插入到非尾结点位置所需时间复杂度为O(n),删除也一样;
    3、扩容规则:
    当我们新建一个vector的时候,会首先分配给他一片连续的内存空间,如std::vector vec,当通过push_back向其中增加元素时,如果初始分配空间已满,就会引起vector扩容,其扩容规则在gcc下以2倍方式完成:
    首先重新申请一个2倍大的内存空间;
    然后将原空间的内容拷贝过来;
    最后将原空间内容进行释放,将内存交还给操作系统;

    注意:
    根据vector的插入和删除特性,以及扩容规则,我们在使用vector的时候要注意,在插入位置和删除位置之后的所有迭代器和指针引用都会失效,同理,扩容之后的所有迭代器指针和引用也都会失效。

    END

    展开全文
  • vector底层实现

    千次阅读 2014-10-24 10:04:12
    //stl库中vector是一个自动管理的动态数组; //其实只要明白vector的类型是一个数组,怎么去实现它,其实就好办了;   //我选择了一种简单的方式去实现它;//定义一个步长(WALK_LENGTH); //在数组...

    //stl库中vector是一个自动管理的动态数组;

    //其实只要明白vector的类型是一个数组,怎么去实现它,其实就好办了;

     

    //我选择了一种简单的方式去实现它;//定义一个步长(WALK_LENGTH);

    //在数组空间不够的时候,重新申请 allocCount+WALK_LENGTH 长度的内存;

    //这样避免了,每次vector元素增加的时候,去重新申请空间;

    //当然,不好的地方也很明显。就是会浪费一定的空间。但是时间效率上会提高很多;

    //因为vector,可以支持下标访问,而且效率很快,所以没必要去构造一个iterator;

     

    //通过分析代码,可以发现vector的优缺点

    //1、随即访问元素效率很高;

    //2、push_back的效率也会很高;

    //3、push_front的效率则非常的低,不建议使用;

    //4、insert,需要把插入位置以后的元素,全部后移,效率比较低,不建议使用;

    //5、erase,需要把删除位置后面的元素,全部前移,效率比较低,不建议使用;

    //6、当内存不够的时候,需要重新申请内存,在把以前的元素拷贝过来,这个时候,效率也是比较低的;

     

    //有不足的地方,还希望大家指正

    [html]  view plain copy
    1. #ifndef _MY_VECTOR_H_  
    2. #define _MY_VECTOR_H_  
    3.   
    4. #include <assert.h>  
    5.   
    6. template<typename T>  
    7. class myVector  
    8. {  
    9. private:  
    10.     //walk length   
    11.     //myVector each time increase space length  
    12.     #define WALK_LENGTH 64;  
    13.   
    14. public:  
    15.     //default constructor  
    16.     myVector():array(0),count(0),allocCount(0)  
    17.     {  
    18.   
    19.     }  
    20.   
    21.     //  
    22.     myVector(const T& t,unsigned int n):array(0),count(0),allocCount(0)  
    23.     {  
    24.         while(n--)  
    25.         {  
    26.             push_back(t);  
    27.         }  
    28.     }  
    29.   
    30.     //copy constructor  
    31.     myVector(const myVector<T>& other):array(0),count(0),allocCount(0)  
    32.     {  
    33.         *this = other;  
    34.     }  
    35.   
    36.     //= operator  
    37.     myVector<T>operator =(myVector<T>& other)  
    38.     {  
    39.         if(this == &other)  
    40.             return *this;  
    41.   
    42.         clear();  
    43.   
    44.         count = other.size();  
    45.         allocCount = other.allocSize();  
    46.         array = new T[allocCount];  
    47.         for(unsigned int i = 0 ;i<count;++i)  
    48.         {  
    49.             array[i] = other[i];  
    50.         }  
    51.   
    52.         return *this;  
    53.     }  
    54.   
    55.     //destructor  
    56.     ~myVector()  
    57.     {  
    58.         clear();  
    59.     }  
    60.   
    61.     //the pos must be less than myVector.size();  
    62.     T& operator[](unsigned int pos)  
    63.     {  
    64.         assert(pos<count);  
    65.         return array[pos];  
    66.     }  
    67.   
    68.     //element count  
    69.     unsigned int size()  
    70.     {  
    71.         return count;  
    72.     }  
    73.   
    74.     //alloc count  
    75.     unsigned int allocSize()  
    76.     {  
    77.         return allocCount;  
    78.     }  
    79.       
    80.     //is  empty  
    81.     bool empty()  
    82.     {  
    83.         return count == 0;  
    84.     }  
    85.   
    86.     //clear myVector  
    87.     void clear()  
    88.     {  
    89.         deallocator(array);  
    90.         array = 0;  
    91.         count = 0;  
    92.         allocCount = 0;  
    93.     }  
    94.   
    95.     //adds an element in the back of myVector   
    96.     void push_back(const T& t)  
    97.     {  
    98.         insert_after(count-1,t);  
    99.     }  
    100.   
    101.     //adds an element int the front of myVector  
    102.     void push_front(const T& t)  
    103.     {  
    104.         insert_before(0,t);  
    105.     }  
    106.   
    107.     //inserts an element after the pos  
    108.     //the pos must be in [0,count);  
    109.     void insert_after(int pos,const T& t)  
    110.     {  
    111.         insert_before(pos+1,t);  
    112.     }  
    113.   
    114.     //inserts an element before the pos  
    115.     //the pos must be less than the myVector.size()  
    116.     void insert_before(int pos,const T& t)  
    117.     {  
    118.         if(count==allocCount)  
    119.         {  
    120.             T* oldArray = array;  
    121.   
    122.             allocCount += WALK_LENGTH;   
    123.             array = allocator(allocCount);  
    124.             //memcpy(array,oldArray,count*sizeof(T)):  
    125.             for(unsigned int i = 0 ;i<count;++i)  
    126.             {  
    127.                 array[i] = oldArray[i];  
    128.             }  
    129.             deallocator(oldArray);  
    130.         }  
    131.   
    132.         for(int i = (int)count++;i>pos;--i)  
    133.         {  
    134.             array[i] = array[i-1];  
    135.         }  
    136.         array[pos] = t;  
    137.     }  
    138.   
    139.     //erases an element in the pos;  
    140.     //pos must be in [0,count);  
    141.     void erase(unsigned int pos)  
    142.     {  
    143.         if(pos<count)  
    144.         {  
    145.             --count;  
    146.             for(unsigned int i = pos;i<count;++i)  
    147.             {  
    148.                 array[i] = array[i+1];  
    149.             }  
    150.         }  
    151.     }  
    152.   
    153. private:  
    154.     T*  allocator(unsigned int size)  
    155.     {  
    156.         return new T[size];  
    157.     }  
    158.   
    159.     void deallocator(T* arr)  
    160.     {  
    161.         if(arr)  
    162.             delete[] arr;  
    163.     }  
    164. private:  
    165.     T*              array;  
    166.     unsigned int    count;  
    167.     unsigned int    allocCount;  
    168. };  
    169.   
    170. #endif  


    //下面的是测试代码

    [html]  view plain copy
    1. void printfVector(myVector<int>& vector1)  
    2. {  
    3.     for(unsigned int i = 0 ; i < vector1.size();++i)  
    4.     {  
    5.         cout<<vector1[i]<<",";  
    6.     }  
    7.     cout<<"alloc size = "<<vector1.allocSize()<<",size = "<<vector1.size()<<endl;  
    8. }  
    9.   
    10. void main()  
    11. {  
    12.     myVector<int> myVector1;  
    13.     myVector<int> myVector2(0,10);  
    14.     myVector2.push_front(1);  
    15.     myVector2.erase(11);  
    16.     printfVector(myVector2);  
    17.     myVector1.push_back(2);  
    18.     myVector1.push_front(1);  
    19.     printfVector(myVector1);  
    20.     myVector1.insert_after(1,3);  
    21.     printfVector(myVector1);  
    22.   
    23.     myVector2 = myVector1;  
    24.     myVector2.insert_before(0,0);  
    25.     myVector2.insert_before(1,-1);  
    26.     printfVector(myVector2);  
    27. }  
    展开全文
  • 前言 list 接口常见的三个实现类 :ArrayList / LinkedList / Vector 三个类的主要保存单列数据,数据有序可重复 创建对象,增删改查方法几乎一摸一样 ...elementData 数组是Object[0] 数组长度为0 size 为0

    前言
    list 接口常见的三个实现类 :ArrayList / LinkedList / Vector
    三个类的主要保存单列数据,数据有序可重复
    创建对象,增删改查方法几乎一摸一样
    保存俩列数据的集合参考我的博客
    https://blog.csdn.net/weixin_43548518/article/details/106201710

    ArrayList底层结构和源码分析
    ArrayList 底层是可变数组,长度可变,数组长度不可变

    ArrayList list = new ArrayList();
    初始化ArrayList的时候底层创建了三个变量
    elementData 数组是Object[0] 数组长度为0
    size 为0
    modCount 为更新次数
    在这里插入图片描述
    当执行一次add 操作时候,这三个变量均有增加
    list.add(“join”);
    elementData 容量扩容为10,0号元素为"john", 其他为null
    size 变为1
    modCount 变为1
    在这里插入图片描述
    当执行到11次add之后,即创建的 elementData = Object[10] 填充完之后
    elementData 扩容为 elementData = Object[15] 是原来1.5 倍
    在这里插入图片描述
    总结
    ArrayList 底层维护了Object[] 数组,名称为elementData
    初始容量为0, 第一次add 数据时候, elementData 容量扩容为10
    再次添加时,如果容量足够,则不扩容直接添加元素到空位上
    再次添加时,如果容量不够,则扩容为原来1.5 倍

    扩容的原理
    初始化ArrayList
    elementData 默认Object[] 容量为0,如下图:

    在这里插入图片描述在这里插入图片描述
    add 方法

    在这里插入图片描述

    扩容方法
    int newCapacity = oldCapacity + (oldCapacity >> 1); 扩容倍率为原来1.5 倍
    Arrays.copyOf(elementData,newCapacity); 新数组代替旧数组

    在这里插入图片描述
    在这里插入图片描述
    Vector底层结构和源码分析
    Vector底层也是可变数组
    Vector 扩容倍率 2倍
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
    capacityIncrement : oldCapacity);

    ArrayList 和 Vector 的对比
    ArrayList & Vector 底层都是可变数组
    Vector 是线程安全的,里面方法有加synchronized,效率较低
    ArrayList 是线程不安全的,效率较高
    Vector 扩容倍率是2倍
    ArrayList 扩容倍率是1.5倍
    在这里插入图片描述
    LinkedList 底层结构和源码分析
    LInkedList 底层是双向链表,不仅实现了list,还实现了Deque队列
    LInkedList 底层维护了俩个节点对象,一个是first 节点,一个是last 节点

    在这里插入图片描述
    first 节点又维护了三个属性,
    item :当天元素
    next: 下一个元素
    prev:上一个元素
    同样item next prev 同样维护了这三个属性
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    LinkedList 在jdk1.7 之前是双向循环列表,之后就是现在的双向链表
    双向循环列表 图(来自网络)

    在这里插入图片描述
    双向链表图
    first节点prev 属性为null
    last 节点next 属性为null
    在这里插入图片描述
    LinkedList 底层添加添加元素的方法
    LinkedList .add("") 方法底层执行LinkLast方法
    在这里插入图片描述
    ArrayList 和数组的对比
    ArrayList 底层是可变数组,长度可变,内存连续
    数组定义之后长度不可变,内存连续
    ArrayList 可以放任意类型的元素
    数组定义之后只能保存一种数据类型,当然多态在引用类数组中使用之后,数组可以保存当前类的类型,也可以保存子类类型
    ArrayList 的工具类为Collections
    数组的工具类为Arrays

    LinkedList 和 ArrayList 对比
    ArrayList 因为要维护数组角标,所以插入&删除数据比较慢
    LinkedList 插入&删除都只是移动指针效率很高
    ArrayList 底层是数组,数组内存连续,改查数据比较快
    LinkedList 底层是双向链表,内存不连续,改查数据比较慢
    当然二者都是有角标的,且都是线程不安全的

    ArrayList Vector LinkedList 三个的选择
    效率方面选择ArrayList & LinkList 不选择Vector
    增刪比较多的用LinKedList
    改查比較多用ArrayList
    因为生产中查询较多,一般已使用ArrayList

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Java集合 Vector底层详解

    千次阅读 2019-05-13 23:42:00
    Java集合的 Vector底层讲解 Vector作为List的另外一个典型的实现类,完全支持List的全部功能,Vector的实现其实和ArrayList的底层实现很类似,都是封装了一个Object[],但Vector是一个比较古老的集合,JDK1.0就已经...
  • 一、ArrayList、Vector、LinkedList三者区别 1、ArrayList 底层:是数组...3、Vector 底层:是数组结构,查询快,增删慢,线程安全,效率低。 注:  1、Vector的方法都是同步的,是线程安全的,而ArrayList的...
  • 底层数据结构是数组,查询快,增删慢 线程安全,效率低 Vector类特有功能 1:添加功能 public void addElement(Object obj) -- add() 2:获取功能 public Object elementAt(int index) -- get() public...
  • 数组是底层数据类型,存放在栈中,其内存的分配和释放完全由系统自动完成,效率最高;动态数组是程序员由new运算符创建的,存放在堆中,需由detele运算符人工释放,否则会内存泄露;vector,存放在堆中,有STL库中...
  • Vec<T>读作'vector(矢量)', 相连... 矢量(vector)数组存储在内存堆(heap)上, 在运行时(runtime)可以增加或减少数组长度.创建let v: Vec<i32> = Vec::new(); let v = vec![1, 2, 3]; // i32 values 更新...
  • Java基础之集合List-ArrayList、LinkedList、Vector底层实现和区别 ArrayList底层实际是采用数组实现的(并且该数组的类型是Object类型的) 如果jdk6,采用Array.copyOf()方法来生成一个新的数组,如果是jdk5,采用...
  • 一、vector数组创建 1、一维数组 一维数组定义为Vector<int> a,就是 int* a=new int[size]; (1)不带参数的构造函数初始化 //初始化一个size为0的vector vector<int> abc; (2)带参数的构造函数初始...
  • 1.问题的提出 在没有了解vector之前,动态数组一般都是又new创建的。在了解vector后发现vector竟是那样方便好用,但方便的同时却是以牺牲执行效率为代价的。...数组是底层数据类型,存放在栈中,其内存的分
  • 我曾经以为动态数组会很快,起码比vector快,然后我在VS2017的编译器试了一下。大家都可以试试。vector肯定针对系统底层的API做优化了,友情提供源代码。 int main() { int n; cin >> n; int *d = new ...
  • #include<iostream>...vector> #include<algorithm> using namespace std; template<typename T> void printEle(T value) { cout << value << endl; } void test() { ...
  • 数组vector区别

    2020-08-11 11:39:02
    数组是存放类型相同的对象的容器,数组的大小确定不变,不能随意向数组中增加元素。 1、定义和初始化内置数组 (1)数组的大小不变,(a[d],d为数组的维度),数组的维度必须是一个常量表达式。定义数组的时,...
  • C++动态数组vector(增删查改)

    千次阅读 2018-08-31 16:54:15
    这里做了比较全面的vector的增删查改操作,以及加入对象,可以理解为JAVA的Collection类,只是API的定义名称有差异而已。 Maqi对象: #include &lt;iostream&gt; #include &lt;cstring&gt; using...
  • vector相当于一个动态数组,随着元素的加入,它的内部机制会自行扩充空间以容纳元素。因此,vector的运用对于内存的合理运用与运用的灵活性有很大的帮助。
  • ArrayList的底层数据结构是一个类型为Object的数组数组的初始长度与创建ArrayList对象时使用的构造方法有关 注:数组“elementData”是用来存储数据、操作数据的数组 “DEFAULTCAPACITY_EMPTY_ELEMENTDATA”是...
  • Vector底层实现原理

    2021-06-02 15:22:59
    Vector底层数组的默认容量:10 若越界了,则自动扩容,扩容的原理:是扩容前的两倍 10–>20—>40—>80 vector是线程安全的,现在使用较少。 如何将非线程安全的ArrayList转换成线程安全的 调用工具类:java...
  • vector底层+扩容

    2021-08-13 09:23:21
    1、底层实现 Vector在堆中分配了一段连续的内存空间来存放元素。 包括三个迭代器,first 指向的是vector中对象的起始字节位置;last指向当前最后一个元素的末尾字节;end指向整个vector容器所占用内存空间的末尾字节...
  • 数组不能为另一个内置类型的数组赋初值,也不允许使用vector对象初始化数组。但是允许使用数组来初始化vector对象,只需指明要拷贝区域的首元素地址和尾后地址就可以了: int test[] = {0, 1, 2, 3, 4, 5}; vector...
  • c++ 数组vector的比较

    2019-10-16 09:04:30
    数组是底层数据类型,存放在栈中,其内存的分配和释放完全由系统自动完成,效率最高; 动态数组是程序员由new运算符创建的,存放在堆中,需由delete运算符人工释放,否则会内存泄露; vector,存放在堆中,由STL库中...
  • C++中数组vector的比较

    千次阅读 2018-06-04 16:45:38
    一、数组C++中数组是一种内置的数据类型。数组是存放类型相同的对象的容器,数组的大小确定不变,不能随意向数组中增加元素。1、定义和初始化内置数组(1)数组的大小不变,(a[d],d为数组的维度),数组的维度必须...
  • C++中之---数组vector

    2019-06-19 13:11:22
    数组是存放类型相同的对象的容器,数组的大小确定不变,不能随意向数组中增加元素。 1、定义和初始化内置数组 (1)数组的大小不变,(a[d],d为数组的维度),数组的维度必须是一个常量表...
  • 实际上,vector类确实使用new 和 delete来管理内存,但这种工作都是底层自动完成的。 模板类array。 vector类的功能逼数组强大,但付出的代价是效率稍低。如果您需要的是长度固定的数组。使用数组是更佳的选择,但...
  • Vector底层原理

    2020-02-18 18:20:45
    1 前言 本人使用的是jdk1.8版本。 2 List集合继承结构 3 ArrayList与Vector的异同 ...ArrayList与Vector高度相似,了解下面的不同点之后可以参考ArrayList。...ArrayList和Vector的底层接口都是...Vector中对底层数组...
  • C++ 中数组vector

    2018-09-21 15:31:52
    首先定义数组必须给出其长度,想要改变其大小也有几种方案 1、用宏定义 #define ARRAYSIZE 10 int array[ARRAYSIZE] 这样每次程序运行时只需改变宏就可以...3、使用STL中的vectorvector就相当于一个动态的数组,可...
  • 数组底层数据类型,存放在栈中,其内存的分配和释放完全由系统自动完成,效率最高 动态数组:程序员由new运算符创建的,存放在堆区,需要delete运算符人工释放,否则会造成内存泄露 vector:存放在堆中,由STL库中...
  • 底层数组实现,使用默认的构造方法,初始化出来的容量是10(JDK 8 无参构造容量为0) //2.扩容的长度是元长度的基础上加二分之一 //3.实现了RandomAccess接口,底层有事数组,get读取元素的性能很好 //4.线程不...
  • C++ STL vector 底层原理

    2020-10-13 11:22:18
    vector中有三个迭代器first,last,end, 分别指向了数组的开头, 数组的结尾+1以及数组的最大容量结尾 迭代器这里可以理解为是指针 当我们有了这三个指针之后, 一些vector的信息很快就能够得到 int first,last,end; //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,425
精华内容 24,570
关键字:

vector底层是数组