深入明白C++ 中的list容器

目次

一、引言
二、list的根本先容
2.1 底层布局
2.2 特性
三、list的使用
3.1 构造函数
3.2 迭代器的使用
3.3 容量相干使用
3.4 元素访问相干使用
3.5 修改器使用
3.6 迭代器失效标题
四、list的模拟实现
4.1 节点界说
4.2 迭代器实现
4.3 list类实现
五、list与vector的对比
表格
六、总结

---

一、引言

在C++ 的尺度模板库（STL）中， list  是一种非常紧张的序列式容器。它以其独特的底层布局和高效的使用接口，在很多场景下发挥偏紧张作用。今天，我们就来深入探究一下  list  容器的方方面面。
二、list的根本先容

2.1 底层布局

 list  的底层是双向链表布局。每个元素存储在独立的节点中，节点通过指针指向前一个元素和后一个元素 ，而且是带头结点的双向循环链表。这意味着在链表中，头结点可以作为一个哨兵节点，方便进行插入和删除使用，同时循环的特性使得从链表的尾部可以无缝毗连到头部。
2.2 特性

   - 插入和删除高效：由于其链表布局，在恣意位置进行插入和删除使用的时间复杂度为 O(1) ，不必要像  vector  那样移动大量元素。
  
  - 双向迭代：支持前后双向迭代，提供了正向迭代器和反向迭代器，方便从差异方向遍历容器。
  
  - 不支持随机访问：与  vector  差异， list  不支持恣意位置的随机访问。假如要访问第  n  个元素，必须从已知位置（如头部或尾部）开始迭代，时间复杂度为 O(n) 。
  三、list的使用

3.1 构造函数

 list  提供了多种构造方式：

1. cpp
3. #include <list>
5. #include <iostream>
9. int main() {
11.     // 构造包含n个值为val的元素的list
13.     std::list<int> list1(5, 10); // 包含5个值为10的元素
17.     // 构造空的list
19.     std::list<int> list2; 
23.     // 拷贝构造
25.     std::list<int> list3(list1); 
29.     // 用[first, last)区间中的元素构造list
31.     std::list<int> list4(list1.begin(), list1.end()); 
35.     for (const auto& num : list1) {
37.         std::cout << num << " ";
39.     }
41.     std::cout << std::endl;
45.     return 0;
47. }

复制代码

3.2 迭代器的使用

迭代器是访问  list  元素的关键工具。 list  提供正向迭代器  begin()  和  end()  ，以及反向迭代器  rbegin()  和  rend()  。

1. cpp
3. #include <list>
5. #include <iostream>
9. int main() {
11.     std::list<int> myList = {1, 2, 3, 4, 5};
15.     // 正向遍历
17.     for (auto it = myList.begin(); it != myList.end(); ++it) {
19.         std::cout << *it << " ";
21.     }
23.     std::cout << std::endl;
27.     // 反向遍历
29.     for (auto rit = myList.rbegin(); rit != myList.rend(); ++rit) {
31.         std::cout << *rit << " ";
33.     }
35.     std::cout << std::endl;
39.     return 0;
41. }

复制代码

必要注意的是， begin()  和  end()  是正向迭代器，对着实行  ++  使用，迭代器向后移动； rbegin()  和  rend()  是反向迭代器，对着实行  ++  使用，迭代器向前移动。
3.3 容量相干使用

-  empty() ：检测  list  是否为空，返回  true  或  false  。

-  size() ：返回  list  中有用节点的个数。

1. cpp
3. #include <list>
5. #include <iostream>
9. int main() {
11.     std::list<int> myList;
13.     std::cout << "Is myList empty? " << (myList.empty()? "Yes" : "No") << std::endl;
17.     myList.push_back(1);
19.     std::cout << "Size of myList: " << myList.size() << std::endl;
23.     return 0;
25. }

复制代码

3.4 元素访问相干使用

-  front() ：返回  list  的第一个节点中值的引用。
-  back() ：返回  list  的末了一个节点中值的引用。

1. cpp
3. #include <list>
5. #include <iostream>
9. int main() {
11.     std::list<int> myList = {10, 20, 30};
13.     std::cout << "First element: " << myList.front() << std::endl;
15.     std::cout << "Last element: " << myList.back() << std::endl;
19.     return 0;
21. }

复制代码

3.5 修改器使用

-  push_front(val) ：在  list  首元素前插入值为  val  的元素。

-  pop_front() ：删除  list  中第一个元素。

-  push_back(val) ：在  list  尾部插入值为  val  的元素。

-  pop_back() ：删除  list  中末了一个元素。

-  insert(position, val) ：在  list  的  position  位置中插入值为  val  的元素。

-  erase(position) ：删除  list  中  position  位置的元素。

-  swap(other_list) ：互换两个  list  中的元素。

-  clear() ：清空  list  中的有用元素。

1. cpp
3. #include <list>
5. #include <iostream>
9. int main() {
11.     std::list<int> myList;
13.     myList.push_back(1);
15.     myList.push_back(2);
17.     myList.push_front(0);
21.     myList.pop_back();
23.     myList.pop_front();
27.     auto it = myList.begin();
29.     myList.insert(it, 10);
33.     myList.erase(it);
37.     std::list<int> anotherList = {3, 4};
39.     myList.swap(anotherList);
43.     myList.clear();
47.     return 0;
49. }

复制代码

3.6 迭代器失效标题

由于  list  的底层是双向链表，在插入元素时，不会导致迭代器失效。但在删除元素时，指向被删除节点的迭代器会失效，其他迭代器不受影响。比方：

1. cpp
3. #include <list>
5. #include <iostream>
9. void TestListIterator() {
11.     int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
13.     std::list<int> l(array, array + sizeof(array) / sizeof(array[0]));
17.     auto it = l.begin();
19.     while (it != l.end()) {
21.         l.erase(it++); // 正确做法，erase后it已经指向下一个有效元素
23.     }
25. }

复制代码

假如写成  l.erase(it); ++it;  ，在  erase  使用后  it  已经失效，再对其进行  ++  使用就会堕落。
四、list的模拟实现

4.1 节点界说

1. cpp
3. template <typename T>
5. struct ListNode {
7.     T data;
8.     ListNode* prev;
9.     ListNode* next;
11.     ListNode(const T& val)
12.         : data(val)
13.         , prev(nullptr)
14.         , next(nullptr)
15.     {}
17. };

复制代码

4.2 迭代器实现

1. cpp
3. template <typename T, typename Ref, typename Ptr>
5. struct ListIterator {
7.     using iterator_category = std::bidirectional_iterator_tag;
9.     using value_type = T;
11.     using reference = Ref;
13.     using pointer = Ptr;
15.     using node = ListNode<T>;
19.     node* ptr;
23.     ListIterator(node* p) : ptr(p) {}
27.     reference operator*() { return ptr->data; }
29.     pointer operator->() { return &(ptr->data); }
33.     ListIterator& operator++() {
35.         ptr = ptr->next;
37.         return *this;
39.     }
41.     ListIterator operator++(int) {
43.         ListIterator temp = *this;
45.         ptr = ptr->next;
47.         return temp;
49.     }
53.     ListIterator& operator--() {
55.         ptr = ptr->prev;
57.         return *this;
59.     }
61.     ListIterator operator--(int) {
63.         ListIterator temp = *this;
65.         ptr = ptr->prev;
67.         return temp;
69.     }
73.     bool operator!=(const ListIterator& other) const { return ptr != other.ptr; }
75.     bool operator==(const ListIterator& other) const { return ptr == other.ptr; }
77. };

复制代码

4.3 list类实现

list访问变量方式为迭代器访问(指针)，list的访问是通过指针来访问其空间的差异节点， ListNode<T>* head;目标是确定哨兵卫，便于后续遍历。

1. cpp
3. template <typename T>
5. class List {
7. private:
9.     ListNode<T>* head;
13. public:
15.     using iterator = ListIterator<T, T&, T*>;
17.     using const_iterator = ListIterator<T, const T&, const T*>;
21.     List() {
23.         head = new ListNode<T>(T());
25.         head->prev = head;
27.         head->next = head;
29.     }
33.     ~List() {
35.         clear();
37.         delete head;
39.     }
43.     iterator begin() {
44.         return iterator(head->next); }
46.     iterator end() {
47.         return iterator(head); }
49.     const_iterator begin() const {
50.         return const_iterator(head->next); }
52.     const_iterator end() const {
53.         return const_iterator(head); }
57.     void push_back(const T& val) {
59.         insert(end(), val);
61.     }
65.     void push_front(const T& val) {
67.         insert(begin(), val);
69.     }
73.     iterator insert(iterator pos, const T& val) {
75.         ListNode<T>* newNode = new ListNode<T>(val);
77.         ListNode<T>* cur = pos.ptr;
79.         newNode->prev = cur->prev;
81.         newNode->next = cur;
83.         cur->prev->next = newNode;
85.         cur->prev = newNode;
87.         return iterator(newNode);
89.     }
93.     iterator erase(iterator pos) {
95.         ListNode<T>* cur = pos.ptr;
97.         ListNode<T>* nextNode = cur->next;
99.         cur->prev->next = cur->next;
101.         cur->next->prev = cur->prev;
103.         delete cur;
105.         return iterator(nextNode);
107.     }
111.     void clear() {
113.         iterator it = begin();
115.         while (it != end()) {
117.             it = erase(it);
119.         }
121.     }
123. };

复制代码

五、list与vector的对比


表格

特性	vector	list
底层布局	动态序次表，一段连续空间	带头结点的双向循环链表
随机访问	支持随机访问，访问某个元素服从 O(1)	不支持随机访问，访问某个元素服从   O(n)
插入和删除	恣意位置插入和删除服从低，必要搬移元素，时间复杂度为 O(n)  ，插入时大概必要增容	恣意位置插入和删除服从高，不必要搬移元素，时间复杂度为   O(1)
空间使用率	底层为连续空间，不轻易造成内存碎片，空间使用率高，缓存使用率高	底层节点动态开辟，末节点轻易造成内存碎片，空间使用率低，缓存使用率低
迭代器	原生态指针	对原生态指针（节点指针）进行封装
迭代器失效	插入元素时，大概导致重新扩容，使原来迭代器失效；删除时，当前迭代器必要重新赋值否则会失效	插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使用场景	必要高效存储，支持随机访问，不关心插入删除服从	大量插入和删除使用，不关心随机访问

完备代码

1. #define _CRT_SECURE_NO_WARNINGS
2. #pragma once
3. #include <iostream>
4. using namespace std;
5. #include <assert.h>
6. namespace ldg
7. {
8.         // List的节点类
9.         template<class T>
10.         struct ListNode
11.         {
12.                 ListNode(const T& val = T())
13.                         : _prev(nullptr)
14.                         , _next(nullptr)
15.                         , _val(val)
16.                 {}
17.                 ListNode<T>* _prev;
18.                 ListNode<T>* _next;
19.                 T _val;
20.         };
22.         /*
24.         List 的迭代器
26.         迭代器有两种实现方式，具体应根据容器底层数据结构实现：
28.          1. 原生态指针，比如：vector
30.          2. 将原生态指针进行封装，因迭代器使用形式与指针完全相同，因此在自定义的类中必须实现以下方法：
32.                  1. 指针可以解引用，迭代器的类中必须重载operator*()
34.                  2. 指针可以通过->访问其所指空间成员，迭代器类中必须重载oprator->()
36.                  3. 指针可以++向后移动，迭代器类中必须重载operator++()与operator++(int)
38.                         至于operator--()/operator--(int)释放需要重载，根据具体的结构来抉择，双向链表可以向前 移动，所以需要重载，如果是forward_list就不需要重载--
40.                  4. 迭代器需要进行是否相等的比较，因此还需要重载operator==()与operator!=()
42.         */
43.         template<class T, class Ref, class Ptr>
44.         class ListIterator
45.         {
46.                 typedef ListNode<T> Node;
47.                 typedef ListIterator<T, Ref, Ptr> Self;
48.                 // Ref 和 Ptr 类型需要重定义下，实现反向迭代器时需要用到
49.         public:
50.                 typedef Ref Ref;
51.                 typedef Ptr Ptr;
52.         public:
53.                 //////////////////////////////////////////////
54.                 // 构造
55.                 ListIterator(Node* node = nullptr)
56.                         : _node(node)
57.                 {}
58.                 //////////////////////////////////////////////
59.                 // 具有指针类似行为
60.                 Ref operator*()
61.                 {
62.                         return _node->_val;
63.                 }
65.                 Ptr operator->()
66.                 {
67.                         return &(operator*());
68.                 }
69.                 //////////////////////////////////////////////
70.                 // 迭代器支持移动
71.                 Self& operator++()
72.                 {
73.                         _node = _node->_next;
74.                         return *this;
75.                 }
77.                 Self operator++(int)
78.                 {
79.                         Self temp(*this);
80.                         _node = _node->_next;
81.                         return temp;
82.                 }
83.                 Self& operator--()
84.                 {
85.                         _node = _node->_prev;
86.                         return *this;
87.                 }
89.                 Self operator--(int)
90.                 {
91.                         Self temp(*this);
92.                         _node = _node->_prev;
93.                         return temp;
94.                 }
95.                 //////////////////////////////////////////////
96.                 // 迭代器支持比较
97.                 bool operator!=(const Self& l)const
98.                 {
99.                         return _node != l._node;
100.                 }
101.                 bool operator==(const Self& l)const
102.                 {
103.                         return _node != l._node;
104.                 }
105.                 Node* _node;
106.         };
107.         template<class Iterator>
108.         class ReverseListIterator
109.         {
110.                 // 注意：此处typename的作用是明确告诉编译器，Ref是Iterator类中的一个类型，而不是静态成员变量
111.                 // 否则编译器编译时就不知道Ref是Iterator中的类型还是静态成员变量
112.                 // 因为静态成员变量也是按照 类名::静态成员变量名 的方式访问的
113.         public:
114.                 typedef typename Iterator::Ref Ref;
115.                 typedef typename Iterator::Ptr Ptr;
116.                 typedef ReverseListIterator<Iterator> Self;
117.         public:
118.                 //////////////////////////////////////////////
119.                 // 构造
120.                 ReverseListIterator(Iterator it)
121.                         : _it(it)
122.                 {}
123.                 //////////////////////////////////////////////
124.                 // 具有指针类似行为
125.                 Ref operator*()
126.                 {
127.                         Iterator temp(_it);
128.                         --temp;
129.                         return *temp;
130.                 }
131.                 Ptr operator->()
132.                 {
133.                         return &(operator*());
134.                 }
135.                 //////////////////////////////////////////////
136.                 // 迭代器支持移动
137.                 Self& operator++()
138.                 {
139.                         --_it;
140.                         return *this;
141.                 }
143.                 Self operator++(int)
144.                 {
145.                         Self temp(*this);
146.                         --_it;
147.                         return temp;
148.                 }
150.                 Self& operator--()
151.                 {
152.                         ++_it;
153.                         return *this;
154.                 }
155.                 Self operator--(int)
156.                 {
157.                         Self temp(*this);
158.                         ++_it;
159.                         return temp;
160.                 }
161.                 //////////////////////////////////////////////
162.                 // 迭代器支持比较
163.                 bool operator!=(const Self& l)const
164.                 {
165.                         return _it != l._it;
166.                 }
167.                 bool operator==(const Self& l)const
168.                 {
169.                         return _it != l._it;
170.                 }
171.                 Iterator _it;
172.         };
174.         template<class T>
175.         class list
176.         {
177.                 typedef ListNode<T> Node;
178.         public:
179.                 // 正向迭代器
180.                 typedef ListIterator<T, T&, T*> iterator;
181.                 typedef ListIterator<T, const T&, const T&> const_iterator;
182.                 // 反向迭代器
183.                 typedef ReverseListIterator<iterator> reverse_iterator;
184.                 typedef ReverseListIterator<const_iterator> const_reverse_iterator;
185.         public:
186.                 ///////////////////////////////////////////////////////////////
187.                 // List的构造
188.                 list()
189.                 {
190.                         CreateHead();
191.                 }
193.                 list(int n, const T& value = T())
194.                 {
195.                         CreateHead();
196.                         for (int i = 0; i < n; ++i)
197.                                 push_back(value);
198.                 }
199.                 template <class Iterator>
200.                 list(Iterator first, Iterator last)
201.                 {
202.                         CreateHead();
203.                         while (first != last)
204.                         {
205.                                 push_back(*first);
206.                                 ++first;
207.                         }
208.                 }
210.                 list(const list<T>& l)
211.                 {
212.                         CreateHead();
214.                         // 用l中的元素构造临时的temp,然后与当前对象交换
215.                         list<T> temp(l.begin(), l.end());
216.                         this->swap(temp);
217.                 }
219.                 list<T>& operator=(list<T> l)
220.                 {
221.                         this->swap(l);
222.                         return *this;
223.                 }
225.                 ~list()
226.                 {
227.                         clear();
228.                         delete _head;
229.                         _head = nullptr;
230.                 }
231.                 ///////////////////////////////////////////////////////////////
232.                 // List的迭代器
233.                 iterator begin()
234.                 {
235.                         return iterator(_head->_next);
236.                 }
238.                 iterator end()
239.                 {
240.                         return iterator(_head);
241.                 }
243.                 const_iterator begin()const
244.                 {
245.                         return const_iterator(_head->_next);
246.                 }
248.                 const_iterator end()const
249.                 {
250.                         return const_iterator(_head);
251.                 }
253.                 reverse_iterator rbegin()
254.                 {
255.                         return reverse_iterator(end());
256.                 }
258.                 reverse_iterator rend()
259.                 {
260.                         return reverse_iterator(begin());
261.                 }
263.                 const_reverse_iterator rbegin()const
264.                 {
265.                         return const_reverse_iterator(end());
266.                 }
268.                 const_reverse_iterator rend()const
269.                 {
270.                         return const_reverse_iterator(begin());
271.                 }
272.                 ///////////////////////////////////////////////////////////////
273.                 // List的容量相关
274.                 size_t size()const
275.                 {
276.                         Node* cur = _head->_next;
277.                         size_t count = 0;
278.                         while (cur != _head)
279.                         {
280.                                 count++;
281.                                 cur = cur->_next;
282.                         }
283.                         return count;
284.                 }
286.                 bool empty()const
287.                 {
288.                         return _head->_next == _head;
289.                 }
290.                 void resize(size_t newsize, const T& data = T())
291.                 {
292.                         size_t oldsize = size();
293.                         if (newsize <= oldsize)
294.                         {
295.                                 // 有效元素个数减少到newsize
296.                                 while (newsize < oldsize)
297.                                 {
299.                                         pop_back();
300.                                         oldsize--;
301.                                 }
302.                         }
303.                         else
304.                         {
305.                                 while (oldsize < newsize)
306.                                 {
307.                                         push_back(data);
308.                                         oldsize++;
309.                                 }
310.                         }
311.                 }
312.                 ////////////////////////////////////////////////////////////
313.                 // List的元素访问操作
314.                 // 注意：List不支持operator[]
315.                 T& front()
316.                 {
317.                         return _head->_next->_val;
318.                 }
319.                 const T& front()const
320.                 {
321.                         return _head->_next->_val;
322.                 }
323.                 T& back()
324.                 {
325.                         return _head->_prev->_val;
326.                 }
327.                 const T& back()const
328.                 {
329.                         return _head->_prev->_val;
330.                 }
331.                 ////////////////////////////////////////////////////////////
332.                 // List的插入和删除
333.                 void push_back(const T& val)
334.                 {
335.                         insert(end(), val);
336.                 }
337.                 void pop_back()
338.                 {
339.                         erase(--end());
340.                 }
341.                 void push_front(const T& val)
342.                 {
343.                         insert(begin(), val);
344.                 }
345.                 void pop_front()
346.                 {
347.                         erase(begin());
348.                 }
350.                 // 在pos位置前插入值为val的节点
351.                 iterator insert(iterator pos, const T& val)
352.                 {
353.                         Node* pNewNode = new Node(val);
354.                         Node* pCur = pos._node;
355.                         // 先将新节点插入
356.                         pNewNode->_prev = pCur->_prev;
357.                         pNewNode->_next = pCur;
358.                         pNewNode->_prev->_next = pNewNode;
359.                         pCur->_prev = pNewNode;
360.                         return iterator(pNewNode);
361.                 }
362.                 // 删除pos位置的节点，返回该节点的下一个位置
363.                 iterator erase(iterator pos)
364.                 {
365.                         // 找到待删除的节点
366.                         Node* pDel = pos._node;
367.                         Node* pRet = pDel->_next;
368.                         // 将该节点从链表中拆下来并删除
369.                         pDel->_prev->_next = pDel->_next;
370.                         pDel->_next->_prev = pDel->_prev;
371.                         delete pDel;
372.                         return iterator(pRet);
373.                 }
375.                 void clear()
376.                 {
377.                         Node* cur = _head->_next;
378.                         // 采用头删除删除
379.                         while (cur != _head)
380.                         {
381.                     _head->_next = cur->_next;
382.                                 delete cur;
383.                                 cur = _head->_next;
384.                         }
385.                         _head->_next = _head->_prev = _head;
386.                 }
388.                 void swap(ldg::list<T>& l)
389.                 {
390.                         std::swap(_head, l._head);
391.                 }
392.         private:
393.                 void CreateHead()
394.                 {
395.                         _head = new Node;
396.                         _head->_prev = _head;
397.                         _head->_next = _head;
398.                 }
399.         private:
400.                 Node* _head;
401.         };
402. }
403. ///////////////////////////////////////////////////////
404. // 对模拟实现的list进行测试
405. // 正向打印链表
406. template<class T>
407. void PrintList(const ldg::list<T>& l)
408. {
409.         auto it = l.begin();
410.         while (it != l.end())
411.         {
412.                 cout << *it << " ";
413.                 ++it;
414.         }
415.         cout << endl;
416. }
417. // 测试List的构造
418. void TestBiteList1()
419. {
420.         ldg::list<int> l1;
421.         ldg::list<int> l2(10, 5);
422.         PrintList(l2);
423.         int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
424.         ldg::list<int> l3(array, array + sizeof(array) / sizeof(array[0]));
425.         PrintList(l3);
426.         ldg::list<int> l4(l3);
427.         PrintList(l4);
428.         l1 = l4;
429.         PrintList(l1);
430. }
431. // PushBack()/PopBack()/PushFront()/PopFront()
432. void TestBiteList2()
433. {
434.         // 测试PushBack与PopBack
435.         ldg::list<int> l;
436.         l.push_back(1);
437.         l.push_back(2);
438.         l.push_back(3);
439.         PrintList(l);
440.         l.pop_back();
441.         l.pop_back();
442.         PrintList(l);
443.         l.pop_back();
444.         cout << l.size() << endl;
445.         // 测试PushFront与PopFront
446.         l.push_front(1);
447.         l.push_front(2);
448.         l.push_front(3);
449.         PrintList(l);
450.         l.pop_front();
451.         l.pop_front();
452.         PrintList(l);
453.         l.pop_front();
454.         cout << l.size() << endl;
455. }
457. // 测试insert和erase
458. void TestBiteList3()
459. {
461.         int array[] = { 1, 2, 3, 4, 5 };
462.         ldg::list<int> l(array, array + sizeof(array) / sizeof(array[0]));
463.         auto pos = l.begin();
464.         l.insert(l.begin(), 0);
465.         PrintList(l);
466.         ++pos;
467.         l.insert(pos, 2);
468.         PrintList(l);
469.         l.erase(l.begin());
470.         l.erase(pos);
471.         PrintList(l);
472.         // pos指向的节点已经被删除，pos迭代器失效
473.         cout << *pos << endl;
474.         auto it = l.begin();
475.         while (it != l.end())
476.         {
477.                 it = l.erase(it);
478.         }
479.         cout << l.size() << endl;
480. }
482. // 测试反向迭代器
484. void TestBiteList4()
485. {
486.         int array[] = { 1, 2, 3, 4, 5 };
487.         ldg::list<int> l(array, array + sizeof(array) / sizeof(array[0]));
488.         auto rit = l.rbegin();
490.         while (rit != l.rend())
491.         {
492.                 cout << *rit << " ";
493.                 ++rit;
494.         }
495.         cout << endl;
496.         const ldg::list<int> cl(l);
497.         auto crit = l.rbegin();
499.         while (crit != l.rend())
500.         {
501.                 cout << *crit << " ";
502.                 ++crit;
503.         }
504.         cout << endl;
505. }

复制代码

六、总结

 list  容器依附其独特的双向链表布局，在插入和删除使用上具有高效性，适用于必要频仍进行这些使用的场景。通过深入明白其接口和实现原理，我们可以在现实编程中更好地运用它，同时与  vector  等其他容器对比，能更清晰地知道在差异需求下如何选择合适的容器。希望这篇博客能资助各人对  list  容器有更全面、深入的认识。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。