精华内容
下载资源
问答
  • vector容器和list容器时STL中最常使用的两个容器,两者之间最大的区别在于它们底层实现的不同,vector的底层实现是基于数组,而list的底层实现是基于双向循环链表。 (list底层结构示意图) 由于vector容器和list...

    vector容器和list容器时STL中最常使用的两个容器,两者之间最大的区别在于它们底层实现的不同,vector的底层实现是基于数组,而list的底层实现是基于双向循环链表。

    在这里插入图片描述
    (list底层结构示意图)

    由于vector容器和list容器底层实现上的差异,导致两者在实现不同功能的效率上也有着一定程度的差别,这一点可以体现vector容器和list容器的优点的不同。

    vector容器的优点:
    1.vector的遍历速度比list更快(list的底层是链表,需要通过指针域才能从一个元素找到下一个元素,而vector的底层是数组,数组的遍历速度是要明显快于链表的)
    2.对于单个元素而言,vector容器的占用内存要少于list(list的每个元素需要额外开辟空间作为指针域)

    list容器的优点:
    1.插入和删除元素时效率更高(链表的插入删除相比于数组会更加高效)
    2.采用动态存储分配,不会造成内存的浪费和溢出(vector数组在执行功能时容易造成内存资源的浪费)
    3.list在执行删除和插入时不会造成原有迭代器的失效,而这一点在vector中是不成立的(vector在扩容时会开辟一段新的内存空间,将原来的元素复制进去,原有的迭代器就失效了)

    总体来说,vector的优势和list的优势是互补的,在实际的运用过程中,认识到vector和list特性的不同并正确选择容器,有利于提高程序运行效率。

    展开全文
  • 求职面试的时候基础题目大都会考vector和list差别,如果你答不上来,那么印象会很糟糕,因为这是区别大学生一个从业多年的重要指标,大学生在校其实用这种数据结构的场合不多,大都数要毕业之后做项目才经常要...

     容器是在项目中常见的数据结构,不仅仅在C++中,很多语言都有封装了类似STL的模板库。因为我选择的是C++方向,所以今天就简单从C++的角度聊一聊模板中vector和list的差别。

     

            求职面试的时候基础题目大都会考vector和list的差别,如果你答不上来,那么印象会很糟糕,因为这是区别大学生和一个从业多年的重要指标,大学生在校其实用这种数据结构的场合不多,大都数要毕业之后做项目才经常要使用STL,boot这些第三方库,所以大都不会自己造轮子,直接新手拈来。

     

        我觉得如果能这样答就基本可以了。从内存来看,vector的内存空间是连续的,你完全可以当成数组使用,支持[]操作符也就是下标索引存取高效,但是插入和删除的效率低,当内存不够时会重新申请足够大的内存并进行内存拷贝,请注意是足够大的内存,我就碰到不要脸的面试官问我一倍够大吗,这个时候你要提醒自己不要跳坑,而申请和拷贝大块内存是非常影响效率的,所以如果是数据量庞大,用vector就是一个错误的选择;

    list是双向链表结构,它的空间是不连续的,通过指针来访问,这样的数据结构决定了不能通过下标索引,但是优点就是插入和删除效率特别高。

     

        如果能从一些数据再深入阐明vector和list的性能就完美了。比如说插入性能对比,多少数据时vector耗时会是list的多少倍,也因此决定了在什么场合更适合list。如果是一些高并发分布式的场合,那么list的用处肯定是更多的,以前就碰到几百万条数据

    展开全文
  • (1.1)vector的头文件 #include <vector> using std::vector; vector<int> v_ints; 或 std::vector<int> v_ints;   (1.2)vector的构造   vector<...

    (1.1)vector的头文件

    #include <vector>

    using std::vector;

    vector<int> v_ints;

    std::vector<int> v_ints;

     

    (1.2)vector的构造

     
    1. vector<int> first; // empty vector of ints

    2. vector<int> second (4,100); // four ints with value 100

    3. vector<int> third (second.begin(),second.end()); // iterating through second

    4. vector<int> fourth (third); // a copy of third

     

     

    (1.3)vector成员函数:

    c.at(idx) , 类似操作符[], 返回索引idx所指的数据的引用,如果idx越界,抛出out_of_range。

    c.begin() 返回指向首部数据的迭代器。返回类型为 vector<T>::iterator。

    c.end() 返回指向尾部数据的迭代器,此迭代器不执行任何内容。

    c.empty() 判断容器是否为空,返回类型bool。

    c.capacity() 返回容器中数据个数,返回类型为size_type。

    c.max_size() 返回容器中最大数据的数量,返回类型为size_type。

    c.size() 返回容器中实际元素的个数,返回类型为size_type。

     

    STL容器的capacity属性,表示STL在发生realloc前能允许的最大元素数,也可以理解为预分配的内存空间。例如一个vector<int> v的capacity为5,当插入第6个元素时,vector会realloc,vector内部数据会复制到另外一个内存区域。这样之前指向vector中的元素的指针、迭代器等等均会失效。
    max_size属性和capacity不同,表示STL容器允许的最大元素数,通常,这个数是一个很大的常整数,可以理解为无穷大。这个数目与平台和实现相关,在我的机器上vector<int>的max_size为1073741823,而string的max_size为4294967294。因为max_size很大~所以基本不会发生元素数超过max_size的情况,只需知道两者区别即可。

    并不是所有的容器都会发生realloc,List,Map/Multimap,Set/Multiset的元素在内存中散布,不预分配内存,所以不会产生realloc的情况,对于这些容器,其capacity是无意义的,所以这些容器没有capacity()成员函数,也没有capacity属性。

     

    void resize(size_type sz, T c=T()), 重新分配大小;

        myvector.resize(5);

        myvector.resize(8,100); // eight of value = 100

     

    c.front() 返回第一个数据的引用。比如vector<string>::front()返回的就是string的引用。

    c.push_back(T) 在尾部加入一个数据,参数为模板类型,是最常用的vector增长方式

    c.pop_back() 删除最后一个数据。原型void pop_back();

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

    c.erase(pos) 删除pos位置的数据,返回下一个数据的iterator。

    c.erase(beg,end) 删除[beg,end)区间的数据,返回下一个数据的iterator。

    下面的例子写出迭代器的基本操作:

    需要注意的是,当想容器中放入类的对象类型时,是先拷贝一份放入,所以类中必须要有拷贝构造函数

    #include "iostream"
    using namespace std;
    #include "vector"
    
    class Teacher                     
    {
    private:
    	int age;
    	char  *name;
    public:
    	Teacher(int age = 0, char *name = NULL)
    	{
    		int n = strlen(name);
    		cout << "n = " << n << endl;
    		if (name != NULL)
    		{
    			this->name = new char[n + 1];
    			strcpy(this->name, name);
    		}
    		this->age = age;
    	}
    
    /*
    	~Teacher()
    	{
    		if (this->name != NULL)
    		{
    			cout << "析构函数" << endl;
    			delete[] name;
    			this->name = NULL;
    			age = 0;
    		}
    		
    	}
    
    */
    	Teacher(const Teacher &obj)                   //拷贝构造函数
    	{
    		this->name = NULL;
    		this->name = new char[strlen(obj.name)];
    		strcpy(this->name, obj.name);
    		this->age = obj.age;
    	}
    
    	void print()
    	{
    		cout << "name = " << name << endl;
    		cout << "age = " << age << endl;
    	}
    };
    
    // 在下面的main函数中,v1.begin() 指在 1, 而v1.end() 指在10 的后面
    void in11()           //遍历容器
    {
    	vector<int> v1(10);
    	for (int i = 0; i < 10; i++)
    	{
    		v1[i] = i + 1;
    	}
    
    	for (vector<int> ::iterator it = v1.begin(); it != v1.end(); it++)         //正向遍历
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    
    	for (vector<int> ::reverse_iterator rit = v1.rbegin(); rit != v1.rend(); rit++)
    	{
    		cout << *rit << " ";
    	}
    	cout << endl;
    }
    
    void playobj( Teacher &const obj)
    {
    	obj.print();
    }
    
    void printV(vector <char> &v1)
    {
    	for (vector<char> ::iterator it = v1.begin(); it != v1.end(); it++)         //正向遍历
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    }
    
    
    void main()
    {
    	Teacher t1(23, "zwt");
    	Teacher t2(22, "lqm");
    	Teacher t3(21, "lqms");
    
    	playobj(t1);
    
    	Teacher t4 = t2;
    	playobj(t4);
    	vector <Teacher> v1;
    	v1.push_back(t1); 
    	v1.push_back(t2);
    	v1.push_back(t3);
    	cout << v1.size() << endl;
    
    
    
    	for (vector<Teacher> ::iterator it = v1.begin(); it != v1.end(); it++)
    	{
    		(*it).print();
    	}
    	
    	cout << "hello. . ." << endl;
    	system("pause");
    }
    
    
    
    void main11()           // 插入和删除
    {
    	vector<char> v1;
    	for (int i = 0; i < 10; i++)
    	{
    		v1.push_back('a' + i);
    	}
    	v1.push_back('\0');
    	for (int i = 0; i < 10; i++)
    	{
    		cout << v1[i];
    	}
    	cout << endl;
    
    	//v1.erase(v1.begin(), v1.begin() + 3);              //区间删除
    	//for (int i = 0; i < v1.size(); i++)
    	//{
    	//	cout << v1[i];
    	//}
    	//cout << endl;
    
    	v1[5] = 'a';
    	v1[6] = 'a';
    	for (vector<char> ::iterator it = v1.begin(); it != v1.end(); it++)         //正向遍历
    	{
    		cout << *it<<" ";
    	}
    	cout << endl;
    
    	for (vector<char> ::iterator it = v1.begin(); it != v1.end();   )         //正向遍历  删除是 a 的元素
    	{
    		if (*it == 'a')
    		{
    			it = v1.erase(it);
    		}
    		else
    		{
    			it++;
    		}
    	}
    
    	printV(v1);
    	cout << "--------------" << endl;
    
    	v1.insert(v1.begin(), 'A');
    	v1.insert(v1.end() , 'B');
    	printV(v1);
    
    
    	system("pause");
    }

     

    展开全文
  • 这个问题的本质还是在问顺序表链表的区别 底层结构不同 vector容器 list容器 一段连续的空间 带头结点的双向循环链表 元素访问方式 vector容器 list容器 支持随机访问—O(1) 不支持随机访问—O...

    这个问题的本质还是在问顺序表和链表的区别

    底层结构不同

    vector容器list容器
    一段连续的空间带头结点的双向循环链表

    元素访问方式

    vector容器list容器
    支持随机访问—O(1)不支持随机访问—O(N)
    需要扩容不需要扩容
    任意位置插入元素----O(N)–搬移元素O(1)

    迭代器不同

    vector容器list容器
    类型:原生态的指针对原生态指针进行封装
    失效的场景:导致底层空间改变操作当前迭代器对应的结点没有了
    erase(it)erase(it)

    空间

    vector容器list容器
    需要扩容不需要扩容
    不扩容的话空间利用率高,扩容不一定不扩容的话空间利用率低,扩容不一定
    vector如果不new是在栈上的list结点是new出来的,频繁向系统申请小的内存块,可能会存在内存碎片。new的底层是malloc,可能会有额外空间的浪费

    缓存利用率

    在这里插入图片描述

    vector容器list容器
    比如上面的图,cpu加载1时有可能把12345全部加载到缓存中,这样效率更高,底层连续而list加载时,一次性加载可能就一两个元素,底层不连续

    应用场景

    vector容器list容器
    高效存储—访问任意位置插入和删除操作比较多

    接口不同

    vector没有push_front,和pop_front,因为它头插和头删的效率比较低

    展开全文
  • 注:读者在阅读本文前,需要有 vector 容器的...链表是顺序容器,允许在序列中的任何位置进行恒定时间插入擦除操作,并在两个方向上进行迭代。 链表容器实现为双向链表; 双向链表可以将它们包含的每个元素存储在...
  • 主要介绍了c++容器listvector、map、set区别与用法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 如果我们需要随机访问一个容器vector要比list好得多。如果我们已知要存储元素的个数则vector 又是一个比list好的选择。如果我们需要的不只是在容器两端插入删除元素则list显然要比vector
  • 序列容器中两个主要的就是vector和listvector在一块连续的内存中存放元素。优点是随机读取指定位置的元素比较快。缺点是在插入非末尾位置的元素效率较低。 list则是双向链接存取元素。优点是插入指定位置的元素...
  • Vector和List容器区别

    2021-08-27 16:22:15
    Vector和List都是STL常见的容器,都能存储不同类型的变量,那么有了Vector容器为什么还需要List容器呢!其实它们各有个的优点,如下列表格所示 容器 Vector List 底层结构 动态顺序表,是一个连续的存储空间...
  • 最近一直在看c++ Primer这本经典著作,看到顺序容器这章,认为有必要总结下它们之间的区别与共同点。 首先明确它们之间的存储方式,vector本质是数组,能实现快速的随机访问,deque也是数组,但是是有两个数组实现...
  • 序列式容器 vectorvector采用一段连续的内存来存储其元素,向vector添加元素的时候,如果容量不足,vector便会重新malloc一段更大的 内存,然后把原内存中的数据memcpy到新的内存中,并free原内存块,然后将...
  • C++中数组很坑,有没有类似Python中list的数据类型呢?类似的就是vectorvector 是同一种类型的对象的集合 ,每个对象都有一个对应的整数索引值。 string 对象一样,标准库将负责管理与存储元素相关的内存。 ...
  • C++三种容器listvector和deque的区别

    万次阅读 多人点赞 2016-05-06 17:35:26
    还有一个就是容器,你会发现要是自己写一个链表、队列,或者是数组的时候,既要花时间还要操心怎么去维护,里面的指针啊,内存够不够用啊,长度问题,有没有可能溢出啊等等一系列的问题等着我们去解决,还是比较头疼...
  • 还有一个就是容器,你会发现要是自己写一个链表、队列,或者是数组的时候,既要花时间还要操心怎么去维护,里面的指针啊,内存够不够用啊,长度问题,有没有可能溢出啊等等一系列的问题等着我们去解决,还是比较头疼...
  • C++容器中列表list和向量vector区别

    千次阅读 2019-02-28 21:24:49
    (1)顺序容器,如vectorlist,deque(双端队列)等 (2)关联容器,如set(集合),multiset(多重集合),map(映射),multimap(多重映射)等 (3)容器适配器,如stack(栈),queue(队列),priority...
  • 【1】请你说一说vector和list区别应用越详细越好 参考回答: 1、概念: 1)Vector 连续存储的容器,动态数组,在堆上分配空间 底层实现:数组 两倍容量增长: vector 增加(插入)新元素时,如果未超过当时的...
  • 在C++实际开发过程中,经常需要实现数据的添加、修改、插入、读取等功能,若程序员...序列容器可分为三种,vector向量容器list列表容器、deque双端队列容器,如下: vector向量容器:可看作一个动态数组,连续存储结
  • 序列式容器-vector/deque/list 1.序列式容器-vector/queue/list三种主要构造方式与四种遍历方式。...vector容器构造函数:--plus deque和list,构造函数源码基本差不多。 1.vector( size_type count, ...
  • vector容器一般被用作创建动态数组,动态数组就像Python中的list结构一样,可以比普通数组拥有更丰富操作方法,下面就为大家整理了一些最常用的操作:
  • STL标准库提供了基本序列容器vectorlist、deque,同时还包括stack、queue、priority_queue 等3种适配器。本文主要介绍基本序列式容器vectorlist、deque。 1、vector类模板 vector是定义在命名空间std内的模板...
  • vector list区别

    2019-04-26 15:59:51
    吃一堑,长一智,做学问就要研究的清楚,透彻,不要模模糊糊,稀里糊涂的用(某题为什么要用list而不用vector???这都不知道,题目怎么做的?CCF2018-12-3) ...stl提供了三个最基本的容器vector,list,d...
  • vector和list区别

    万次阅读 2018-08-30 21:26:32
    stl提供了三个最基本的容器vector,list,deque。 vector和built-in数组类似,它拥有一段连续的内存空间,并且起始地址不变,因此它能非常好的支持随即存取,即[]操作符,但由于它的内存空间是连续的,所以在中间...
  • C++中数组、链表和vector容器之间的区别

    万次阅读 多人点赞 2016-10-12 09:05:04
    1. 各个容器之间区别vector  (连续的空间存储,可以使用[]操作符)快速的访问随机的元素,快速的在末尾插入元素,但是在序列中间岁间的插入,删除元素要慢,而且如果一开始分配的空间不够的话,有一个重新分配...
  • 一.string类和vector<char>的区别 string类是一个保存字符的动态数组,由于其中有一个接口c_str,转化成c语言的字符串,要以\0结尾,所以string类最后会有一个\0. ...二.vector和list比较 ...
  • 目录一、list介绍二、list创建三、list方法对比vector四、list的具体用法4.1 iterators4.2 Capacity4.3 Element access4.4 Modifierspush_front、push_back、...ifuniquesortmergereverse五、list和vector对比参考
  • 最近常用的几个容器就是vectorlist和deque。 vector和数组类似,拥有连续的内存空间,其起始地址是固定不变的,因此能支持很好地随机存取,也就是能像数组一样通过[]来访问其元素。vector使用动态数组的方式实现...
  • vector容器用法详解

    千次阅读 2019-05-05 10:17:44
    类模板std::vector 容器属性 函数总览: Iterators(迭代器): begin:将迭代器返回到开头。 end:将迭代器返回到结束。 rbegin:返回反向迭代器以反向开始。 rend:将反向迭代器返回到反向结束。 Capacity...
  • 简介====================================...分配连续存储元素的内存空间会影响内存分配策略和容器对象的开销。 容器是否连续存储还会显著影响: 在容器中间位置添加或删除元素的代价; ** 指向容器元素的随机访问的代

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,359
精华内容 34,543
关键字:

vector容器和list的区别