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

怼烎@ 2022-11-26 01:45 203阅读 0赞

在写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() (****但是QList是支持的****)**  
               (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个元素，不能增加了，里面的元素也是不能变化的*

1.  `vector<int> a(10);`
2.  `const vector<int> b(10);`
3.  `a[1]=10;//正确`
4.  `b[1]=10;//错误`
5.  `a.resize(20);//正确`
6.  `b.resize(20);//错误`

1.  `vector <const int> vec(10); //目前没有这种用法;这样写后也是当作vector <int>vec来用的；`
2.  `关于vector<const int> ，在GCC下是没有这种用法的,编译不过`
3.  `在VS2008是把它当作vector<int>这种类型来处理的；`

**问题三：capacity V.S size**  
    a、capacity是容器需要增长之前，能够盛的元素总数；只有连续存储的容器才有capacity的概念（例如vector，deque，string），list不需要capacity。  
    b、size是容器当前存储的元素的数目。  
    c、vector默认的容量初始值，以及增长规则是依赖于编译器的。  
**问题四：用vector存储自定义类对象时，自定义类对象须满足：**  
    a、有可供调用的无参构造函数（默认的或自定义的）；

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

**问题五：[迭代器iterator][iterator]**[   ][iterator]

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

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

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

vector代码实例：

1.  `#include <iostream>`
2.  `using namespace std;`
3.  `#include <vector> //向量的头文件；`
4.  `#include <algorithm> //算法的头文件；`
5.  `int main()`
6.  `{`
7.  `vector <int> vec(5,8);`
8.  `//--类型是vector<int>，该容器向量中含有5个int类型的数值8，变量名为vec。`
9.  `//vector是一个类模板（class template）,所以必须要声明其类型，int，一个容器中所有的对象必须是同一种类型；`
10. `// 定义一个容器对象；直接构造出一个数组；用法和数组一样；`
11. `//`
12. `for(int i=0;i<vec.size();i++) //size()是指容器里当前有多少个使用的元素；`
13. `{`
14. `cout<<vec[i]<<" ";`
15. `}`
16. `cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl; //得到容器里用的多少个空间，和总共的大小；`
17. `vector<int>::iterator ite; //定义了一个向量的迭代器；相当于定义了一个指针；`
18. `for(ite=vec.begin();ite!=vec.end();ite++) //得到开始、结束`
19. `{`
20. `cout<<*ite <<" "; //迭代器返回的是引用：`
21. `}`
22. `cout<<endl;`
23. `//在尾部插入；`
24. `vec.push_back(9); //VS6.0扩充的空间是两倍；在VS2005扩充的空间是1.5倍；`
25. `for(ite=vec.begin();ite!=vec.end();ite++) //得到开始、结束`
26. `{`
27. `cout<<*ite <<" ";`
28. `}`
29. `cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;`
30.  
31. `//尾部删除;容量没变【capacitty】，但是使用空间减少一个；容量一旦增加就不会减小；`
32. `vec.pop_back();`
33. `for(ite=vec.begin();ite!=vec.end();ite++) //得到开始、结束`
34. `{`
35. `cout<<*ite <<" ";`
36. `}`
37. `cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;`
38.  
39. `vec.push_back(88);`
40. `vec.push_back(99); //容量刚好够；`
41.  
42. `for(ite=vec.begin();ite!=vec.end();ite++) //得到开始、结束`
43. `{`
44. `cout<<*ite <<" ";`
45. `}`
46. `cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;`
47.  
48. `ite = find(vec.begin(),vec.end(),88); //查找这个元素；`
49. `vec.erase(ite); //利用迭代器指针删除这个元素；`
50. `for(int i=0;i<vec.size();i++) //size()是指容器里当前有多少个使用的元素；`
51. `{`
52. `cout<<vec[i]<<" ";`
53. `}`
54. `cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl; //得到容器里用的多少个空间，和总共的大小；`
55.  
56. `vec.clear(); //只是清除了数据，没有回收空间，空间的等到对象的生命周期结束时回收；`
57. `//使用空间为0，但是容量的空间还在，只有在调用析构函数的时候空间才会回收；`
58.  
59. `for(int i=0;i<vec.size();i++) //size()是指容器里当前有多少个使用的元素；`
60. `{`
61. `cout<<vec[i]<<" ";`
62. `}`
63. `cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;`
64.  
65. `ite=find(vec.begin(),vec.end(),88);`
66. `vec.insert(ite,2,77); //迭代器标记的位置前，插入数据；`
67.  
68. `<span style="color:#ff0000;">//cout<<*ite<<endl; //会崩溃，因为迭代器在使用后就释放了，*ite的时候就找不到它的地址了；`
69. `//和向量的用法一样，但是链表list不同，它的迭代器在使用后还可以继续用；链表特有的；</span>`
70.  
71. `for(int i=0;i<vec.size();i++)`
72. `{`
73. `cout<<vec[i]<<" ";`
74. `}`
75. `cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;`
76.  
77. `system("pause");`
78. `return 0;`
79. `}`

运行结果：  
![Center][]

**list代码示例：**

1.  `#include<iostream>`
2.  `#include <list>`
3.  `#include <algorithm>`
4.  `using namespace std;`
5.  `int main()`
6.  `{`
7.  `list<char> lit;`
8.  `//用法和向量一样，`
9.  `//list是一个类模板，template，char是链表里对象的类型，lit是创建的一个对象；`
10. `//链表可以再头尾两端插入,是双向的；`
11.  
12. `lit.push_back('a');`
13. `lit.push_back('b');`
14. `lit.push_front('d');`
15. `lit.push_front('e');`
16. `lit.push_front('f');`
17. `lit.push_front('b');`
18. `lit.push_front('b');`
19.  
20. `list<char>::iterator it; //定义一个list的迭代器，类似一个纸箱链表的指针，但是比一般的指针好用，里面用到了好多重载操作；`
21. `list<char>::iterator it1;`
22. `list<char>::iterator it2;`
23. `for(it=lit.begin();it!=lit.end();it++)`
24. `{`
25. `cout<<*it<<" ";`
26. `}`
27. `cout<<endl;`
28. `//-----------链表可以从两端删除-------------------`
29. `lit.pop_back();`
30. `lit.pop_front();`
31. `for(it=lit.begin();it!=lit.end();it++)`
32. `{`
33. `cout<<*it<<" ";`
34. `}`
35. `cout<<endl;`
36. `//-------------删除所有的a---------------------------------`
37. `//lit.remove('a'); //删除所有的a;`
38.  
39. `for(it=lit.begin();it!=lit.end();it++)`
40. `{`
41. `cout<<*it<<" ";`
42. `}`
43. `cout<<endl;`
44. `//-------------移除连续且相同的a，只剩下一个;--------------------------------`
45. `lit.unique(); //移除连续且相同的a，只剩下一个;`
46.  
47. `for(it=lit.begin();it!=lit.end();it++)`
48. `{`
49. `cout<<*it<<" ";`
50. `}`
51. `cout<<endl;`
52. `list<char> lit1;`
53. `lit1.push_back('g');`
54. `lit1.push_back('h');`
55. `lit1.push_back('i');`
56. `lit1.push_back('k');`
57. `for(it1=lit1.begin();it1!=lit1.end();it1++)`
58. `{`
59. `cout<<*it1<<" ";`
60. `}`
61. `cout<<endl;`
62. `//-------------将一个链表插入到另一个链表---------------------------------`
63. `it1=find(lit.begin(),lit.end(),'f'); //先的找到要插入的位置，在该位置的前一个插入；`
64. `lit.splice(it1,lit1); //将第二个链表插入到第一个链表中；合并后的链表就没了，因为传的是&；`
65. `for(it=lit.begin();it!=lit.end();it++)`
66. `{`
67. `cout<<*it<<" ";`
68. `}`
69. `cout<<endl;`
70. `//------在链表lit中的it前插入lit1中的一个元素it1；在f之前插入k-----`
71. `//-----拿下来之后那个元素就没有了-------------------`
72. `it=find(lit.begin(),lit.end(),'f');`
73. `it1=find(lit1.begin(),lit1.end(),'k');`
74. `lit.splice(it,lit1,it1);`
75. `//-------------把链表中的一段插入到另一个链表中---------------------------------`
76. `//把链表lit1中的[it-----it1)段的字符插入到lit的it2指针前；`
77. `it=find(lit1.begin(),lit1.end(),'h');`
78. `it1=find(lit1.begin(),lit1.end(),'k');`
79. `it2=find(lit.begin(),lit.end(),'f');`
80. `lit.splice(it2,lit1,it,it1);`
81. `// ----void merge(list& x); //将x合并到*this 身上。两个lists 的内容都必须先经过递增归并排序。`
82. `lit.sort(); //对两个排序进行归并排序；`
83. `lit1.sort();`
84. `lit.merge(lit1);`
85. `//-----------将list里的数据倒序排列---------------`
86. `lit.reverse();`
87. `for(it=lit.begin();it!=lit.end();it++)`
88. `{`
89. `cout<<*it<<" ";`
90. `}`
91. `cout<<endl;`
92. `for(it1=lit1.begin();it1!=lit1.end();it1++)`
93. `{`
94. `cout<<*it1<<" ";`
95. `}`
96. `cout<<endl;`
97. `system("pause");`
98. `return 0;`
99. `}`
100.  
101.

运行结果：

![Center 1][]

[iterator]: http://blog.csdn.net/gogokongyin/article/details/51206225
[Center]: /images/20221124/955506a0608b4b7f96c9d67ac4aa3d9a.png
[Center 1]: /images/20221124/29985f725f6641388710058f4b1355f8.png