C++三种容器:list、vector和deque的区别

           在写C++程序的时候会发现STL是一个不错的东西,减少了代码量,使代码的复用率大大提高,减轻了程序猿的负担。还有一个就是容器,你会发现要是自己写一个链表、队列,或者是数组的时候,既要花时间还要操心怎么去维护,里面的指针啊,内存够不够用啊,长度问题,有没有可能溢出啊等等一系列的问题等着我们去解决,还是比较头疼的。所以容器的出现解决了这一个问题,它将这些数据结构都封装成了一个类,只需要加上头文件,我们就可以轻松的应用,不用那么复杂,就连指针也被封装成了迭代器,用起来更方便,更人性化,方便了我们的编程,对于程序员来说还是一大福音!!

          C++中的容器类包括“顺序存储结构”和“关联存储结构”,前者包括vector,list,deque等;后者包括set,map,multiset,multimap等。若需要存储的元素数在编译器间就可以确定,可以使用数组来存储,否则,就需要用到容器类了。

1、vector
     连续存储结构,每个元素在内存上是连续的;支持 高效的随机访问和在尾端插入/删除操作,但其他位置的插入/删除操作效率低下; 相当于一个数组,但是与数组的区别为:内存空间的扩展。vector支持不指定vector大小的存储,但是数组的扩展需要程序员自己写。
    vector的内存分配实现原理:
    STL内部实现时,首先分配一个非常大的内存空间预备进行存储,即capacity()函数返回的大小,当超过此分配的空间时再整体重新放分配一块内存存储( VS6.0是两倍,VS2005是1.5倍),所以 这给人以vector可以不指定vector即一个连续内存的大小的感觉。通常此默认的内存分配能完成大部分情况下的存储。
    扩充空间(不论多大)都应该这样做:
   (1)配置一块新空间
   (2)将旧元素一一搬往新址
   (3)把原来的空间释放还给系统
    注:vector 的数据安排以及操作方式,与array 非常相似。两者的唯一差别在于空间的利用的灵活性。Array 的扩充空间要程序员自己来写。
    vector类定义了好几种构造函数,用来定义和初始化vector对象:
    vector<T>  v1;  vector保存类型为T的对象。默认构造函数v1为空。
    vector<T> v2(v1);  v2是v1的一个副本。
    vector<T> v3(n, i);  v3包含n个值为i的元素。
    vector<T> v4(n);   v4含有值初始化的元素的n个副本。
2、deque
     连续存储结构,即其每个元素在内存上也是连续的,类似于vector,不同之处在于, deque提供了两级数组结构, 第一级完全类似于vector,代表实际容器;另一级维护容器的首位地址。这样,deque除了具有vector的所有功能外, 还支持高效的首/尾端插入/删除操作。
    deque   双端队列 double-end queue
    deque是在功能上合并了vector和list。
     优点:(1) 随机访问方便,即支持[ ]操作符和vector.at()
                (2) 在内部方便的进行插入和删除操作
                (3) 可在两端进行push、pop
     缺点:占用内存多
   使用区别:
     (1)如果你需要高效的随即存取,而不在乎插入和删除的效率,使用vector
     (2)如果你需要大量的插入和删除,而不关心随机存取,则应使用list
     (3)如果你需要随机存取,而且关心两端数据的插入和删除,则应使用deque
3、list
     非连续存储结构,具有双链表结构,每个元素维护一对前向和后向指针,因此支持前向/后向遍历。 支持高效的随机插入/删除操作,但随机访问效率低下,且由于需要额外维护指针 ,开销也比较大。每一个结点都包括一个信息快Info、一个前驱指针Pre、一个后驱指针Post。可以不分配必须的内存大小方便的进行添加和删除操作。使用的是非连续的内存空间进行存储。
    优点:(1) 不使用连续内存完成动态操作。
               (2) 在内部方便的进行插入和删除操作
               (3) 可在两端进行push、pop
    缺点:(1) 不能进行内部的随机访问,即不支持[ ]操作符和vector.at()
               (2) 相对于verctor占用内存多
    使用区别:
             (1)如果你需要高效的随即存取,而不在乎插入和删除的效率,使用vector
             (2)如果你需要大量的插入和删除,而不关心随机存取,则应使用list
             (3)如果你需要随机存取,而且关心两端数据的插入和删除,则应使用deque
4、vector VS. list VS. deque:
    a、若需要随机访问操作,则选择vector;
    b、若已经知道需要存储元素的数目,则选择vector;
    c、若需要随机插入/删除(不仅仅在两端),则选择list
    d、只有需要在首端进行插入/删除操作的时候,还要兼顾随机访问效率,才选择deque,否则都选择vector。
    e、若既需要随机插入/删除,又需要随机访问,则需要在vector与list间做个折中-deque。
    f、当要存储的是大型负责类对象时,list要优于vector;当然这时候也可以用vector来存储指向对象的指针,
       同样会取得较高的效率,但是指针的维护非常容易出错,因此不推荐使用。

问题一:list和vector的区别:
(1)vector为存储的对象分配一块连续的地址空间 ,随机访问效率很高。但是 插入和删除需要移动大量的数据,效率较低。尤其当vector中存储
的对象较大,或者构造函数复杂,则在对现有的元素进行拷贝的时候会执行拷贝构造函数。
(2)list中的对象是离散的,随机访问需要遍历整个链表, 访问效率比vector低。但是在list中插入元素,尤其在首尾 插入,效率很高,只需要改变元素的指针。

(3)vector是单向的,而list是双向的;

(4)向量中的iterator在使用后就释放了,但是链表list不同,它的迭代器在使用后还可以继续用;链表特有的;

  使用原则:
(1)如果需要高效的随机存取,而不在乎插入和删除的效率,使用vector;
(2)如果需要大量高效的删除插入,而不在乎存取时间,则使用list;
(3)如果需要搞笑的随机存取,还要大量的首尾的插入删除则建议使用deque,它是list和vector的折中;
问题二:常量容器const
     const vector<int> vec(10);//这个容器里 capacity和size和值都是不能改变的, const修饰的是vector
     迭代器:const vector<int>::const_iterrator ite; //常量迭代器;
       注:const vector <int> vec(10) —— 与const int a[10]是一回事,意思是vec只有10个元素,不能增加了,里面的元素也是不能变化的
vector<int> a(10);
const vector<int> b(10);
a[1]=10;//正确
b[1]=10;//错误
a.resize(20);//正确
b.resize(20);//错误
vector <const int> vec(10);  //目前没有这种用法;这样写后也是当作vector <int>vec来用的;
关于vector<const int> ,在GCC下是没有这种用法的,编译不过
在VS2008是把它当作vector<int>这种类型来处理的;
问题三:capacity V.S size
    a、capacity是容器需要增长之前,能够盛的元素总数; 只有连续存储的容器才有capacity的概念(例如vector,deque,string),list不需要capacity。
    b、size是容器当前存储的元素的数目。
    c、vector默认的容量初始值,以及增长规则是依赖于编译器的。
问题四:用vector存储自定义类对象时,自定义类对象须满足:
    a、有可供调用的无参构造函数(默认的或自定义的);

    b、有可用的拷贝赋值函数(默认的或自定义的)

问题五:迭代器iterator   

     a、vector与deque的迭代器支持算术运算,list的迭代器只能进行++/--操作,不支持普通的算术运算。

     b .向量中的iterator在使用后就释放了,但是链表list不同,它的迭代器在使用后还可以继续用;链表特有的;

     ite=find(vec.begin(),vec.end(),88);
     vec.insert(ite,2,77);  //迭代器标记的位置前,插入数据;
     cout<<*ite<<endl;  //会崩溃,因为迭代器在使用后就释放了,*ite的时候就找不到它的地址了;


vector代码实例:

#include <iostream>
using namespace std;
#include <vector>   //向量的头文件;
#include <algorithm> //算法的头文件;
int main()
{
	vector <int> vec(5,8);
	//--类型是vector<int>,该容器向量中含有5个int类型的数值8,变量名为vec。
	//vector是一个类模板(class template),所以必须要声明其类型,int,一个容器中所有的对象必须是同一种类型;
	// 定义一个容器对象;直接构造出一个数组;用法和数组一样;
	// 	
	 	for(int i=0;i<vec.size();i++)   //size()是指容器里当前有多少个使用的元素;
	 	{
	 		cout<<vec[i]<<"  ";
	 	}	
		cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  //得到容器里用的多少个空间,和总共的大小;
	 vector<int>::iterator ite;  //定义了一个向量的迭代器;相当于定义了一个指针;
	for(ite=vec.begin();ite!=vec.end();ite++)   //得到开始、结束
	{
		cout<<*ite <<" ";  //迭代器返回的是引用:
	}
        cout<<endl;
	//在尾部插入;
	vec.push_back(9);  //VS6.0扩充的空间是两倍;在VS2005扩充的空间是1.5倍;
	for(ite=vec.begin();ite!=vec.end();ite++)   //得到开始、结束
	{
		cout<<*ite <<" ";
	}
	cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;

	//尾部删除;容量没变【capacitty】,但是使用空间减少一个;容量一旦增加就不会减小;
	vec.pop_back();
	for(ite=vec.begin();ite!=vec.end();ite++)   //得到开始、结束
	{
		cout<<*ite <<" ";
	}
	cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;

	vec.push_back(88);  
	vec.push_back(99); //容量刚好够;

	for(ite=vec.begin();ite!=vec.end();ite++)   //得到开始、结束
	{
		cout<<*ite <<" ";
	}
	cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;

	ite = find(vec.begin(),vec.end(),88);   //查找这个元素;
	vec.erase(ite);  //利用迭代器指针删除这个元素;
	for(int i=0;i<vec.size();i++)   //size()是指容器里当前有多少个使用的元素;
	{
		cout<<vec[i]<<" ";
	}
	cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  //得到容器里用的多少个空间,和总共的大小;

	vec.clear(); //只是清除了数据,没有回收空间,空间的等到对象的生命周期结束时回收;
	//使用空间为0,但是容量的空间还在,只有在调用析构函数的时候空间才会回收;

	for(int i=0;i<vec.size();i++)   //size()是指容器里当前有多少个使用的元素;
	{
		cout<<vec[i]<<"  ";
	}
	cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;

	ite=find(vec.begin(),vec.end(),88);
	vec.insert(ite,2,77);  //迭代器标记的位置前,插入数据;

	<span style="color:#ff0000;">//cout<<*ite<<endl;  //会崩溃,因为迭代器在使用后就释放了,*ite的时候就找不到它的地址了;
	//和向量的用法一样,但是链表list不同,它的迭代器在使用后还可以继续用;链表特有的;</span>

	for(int i=0;i<vec.size();i++)   
	{
		cout<<vec[i]<<"  ";
	}
	cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;

	system("pause");
	return 0;
}
运行结果:

list代码示例:

#include<iostream>
#include <list>
#include <algorithm>
using namespace  std;
int main()
{
	list<char> lit; 
	//用法和向量一样,
	//list是一个类模板,template,char是链表里对象的类型,lit是创建的一个对象;
	//链表可以再头尾两端插入,是双向的;

	lit.push_back('a');
	lit.push_back('b');
	lit.push_front('d');
	lit.push_front('e');
	lit.push_front('f');
	lit.push_front('b');
	lit.push_front('b');

	list<char>::iterator it;  //定义一个list的迭代器,类似一个纸箱链表的指针,但是比一般的指针好用,里面用到了好多重载操作;
	list<char>::iterator it1;  
	list<char>::iterator it2;  
	for(it=lit.begin();it!=lit.end();it++)
	{
		cout<<*it<<"  ";
	}
	cout<<endl;
	//-----------链表可以从两端删除------------------- 
	lit.pop_back();  
	lit.pop_front();
	for(it=lit.begin();it!=lit.end();it++)
	{
		cout<<*it<<"  ";
	}
	cout<<endl;
	//-------------删除所有的a---------------------------------
	//lit.remove('a');  //删除所有的a;

	for(it=lit.begin();it!=lit.end();it++)
	{
		cout<<*it<<"  ";
	}
	cout<<endl;
	//-------------移除连续且相同的a,只剩下一个;--------------------------------
	lit.unique();  //移除连续且相同的a,只剩下一个;

	for(it=lit.begin();it!=lit.end();it++)
	{
		cout<<*it<<"  ";
	}
	cout<<endl;
	list<char> lit1;
	lit1.push_back('g');
	lit1.push_back('h');
	lit1.push_back('i');
	lit1.push_back('k');
	for(it1=lit1.begin();it1!=lit1.end();it1++)
	{
		cout<<*it1<<"  ";
	}
	cout<<endl;
	//-------------将一个链表插入到另一个链表---------------------------------
	it1=find(lit.begin(),lit.end(),'f');  //先的找到要插入的位置,在该位置的前一个插入;
	lit.splice(it1,lit1); //将第二个链表插入到第一个链表中;合并后的链表就没了,因为传的是&;
	for(it=lit.begin();it!=lit.end();it++)
	{
		cout<<*it<<"  ";
	}
	cout<<endl;
	//------在链表lit中的it前插入lit1中的一个元素it1;在f之前插入k-----
	//-----拿下来之后那个元素就没有了-------------------
	it=find(lit.begin(),lit.end(),'f');
	it1=find(lit1.begin(),lit1.end(),'k');
	lit.splice(it,lit1,it1);
	//-------------把链表中的一段插入到另一个链表中---------------------------------
	//把链表lit1中的[it-----it1)段的字符插入到lit的it2指针前;
	it=find(lit1.begin(),lit1.end(),'h');
	it1=find(lit1.begin(),lit1.end(),'k');
	it2=find(lit.begin(),lit.end(),'f');
	lit.splice(it2,lit1,it,it1); 
	// ----void merge(list& x);	//将x合并到*this 身上。两个lists 的内容都必须先经过递增归并排序。
	lit.sort();   //对两个排序进行归并排序;
	lit1.sort();
	lit.merge(lit1);
	//-----------将list里的数据倒序排列---------------
	lit.reverse();
	for(it=lit.begin();it!=lit.end();it++)
	{
		cout<<*it<<"  ";
	}
	cout<<endl;
	for(it1=lit1.begin();it1!=lit1.end();it1++)
	{
		cout<<*it1<<"  ";
	}
	cout<<endl;
	system("pause");
	return 0;
}


运行结果:



已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页