ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【C++】——list 容器的解析与极致实现 [打印本页]

---

作者: 饭宝    时间: 2024-10-18 04:52
标题: 【C++】——list 容器的解析与极致实现

人的一切痛苦，本质上都是对自己的无能的愤怒。

—— 王小波

---

目次
1、list 介绍
2、list的使用
2.1 list 的构造
2.2 iterator 的使用
2.3 list 的修改
2.4一些特殊接口
2.5 迭代器失效题目
3、实现list
3.1底层结构
结点类
list类
迭代器类
3.2功能接口
迭代器接口
插入删除
拷贝赋值析构函数
4、list与vector 区别对比

---

1、list 介绍

List是C++标准模板库(STL)中的一个成员，其本质为带头双向循环链表。差别于连续的、精密排列的数组容器Vector，List容器的内部是由双向链表构成的，使得它在插入和删除操作上，就如同行云流水一样平常顺畅，不需移动其它元素。
List的结构示意图如下：环状链表的尾是一个空节点，符合“左闭右开”区间。

List得当的场景是那些需要频繁进行插入和删除操作的场所。
例如，如果你正在管理一个动态变化的列表，如使命调度、职员列队等场景，List的特性将大放异彩。但是如果你的应用场景更多地需要随机访问元素，那么Vector或者数组可能是更佳的选择。因为List的顺序访问性能相比之下会显得有些力有未逮。

• 以是如果需要频繁随机的访问数据，那么选择vector容器
  
• 如果需要频繁插入删除数据，那么选择list容器
  
• 排序不要选择list ！！！可以先拷贝给vector排序后再拷贝回来
  

迭代器的介绍
迭代器可以按照功能、性质两大模块分类

迭代器的一些性质（重载的运算符）决定着算法库里对算法的调用

而这些迭代器是子类与父类的继承关系

2、list的使用

list 中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的本领。以下为list中一些常见的重要接口。
2.1 list 的构造

1. void TestList1()
2. {
3.         list<int> l1;                         // 构造空的l1
4.         list<int> l2(4, 100);                 // l2中放4个值为100的元素
5.         list<int> l3(l2.begin(), l2.end());  // 用l2的[begin(), end()）左闭右开的区间构造l3
6.         list<int> l4(l3);                    // 用l3拷贝构造l4
8.         // 以数组为迭代器区间构造l5
9.         int array[] = { 16,2,77,29 };
10.         list<int> l5(array, array + sizeof(array) / sizeof(int));
12.         // 列表格式初始化C++11
13.         list<int> l6{ 1,2,3,4,5 };
14.         list<int> l7 = { 1,2,4,5,6,7,8 };
15.         // 用迭代器方式打印l5中的元素
16.         list<int>::iterator it = l5.begin();
17.         while (it != l5.end())
18.         {
19.                 cout << *it << " ";
20.                 ++it;
21.         }
22.         cout << endl;
24.         // C++11范围for的方式遍历
25.         for (auto& e : l5)
26.                 cout << e << " ";
28.         cout << endl;
29. }

复制代码

2.2 iterator 的使用

关于 list 的迭代器可以姑且理解为指针，本质是通过运算符重载模拟指针的行为

【TIP】

•  begin 与 end 为正向迭代器，对迭代器实行++操作，迭代器向后移动
  
• rbegin(end) 与 rend(begin) 为反向迭代器，对迭代器实行++操作，迭代器向前移动
  

1. void PrintList(const list<int>& l)
2. {
3.         // 注意这里调用的是list的 begin() const，返回list的const_iterator对象
4.         for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it)
5.         {
6.                 cout << *it << " ";
7.                 // *it = 10; 编译不通过
8.         }
10.         cout << endl;
11. }
13. void TestList2()
14. {
15.         int array[] = { 1, 2, 3, 4, 5, 6, };
16.         list<int> l(array, array + sizeof(array) / sizeof(array[0]));
17.         // 使用正向迭代器正向list中的元素
18.         // list<int>::iterator it = l.begin();   // C++98中语法
19.         auto it = l.begin();                     // C++11之后推荐写法
20.         while (it != l.end())
21.         {
22.                 cout << *it << " ";
23.                 ++it;
24.         }
25.         cout << endl;
27.         // 使用反向迭代器逆向打印list中的元素
28.         // list<int>::reverse_iterator rit = l.rbegin();
29.         auto rit = l.rbegin();
30.         while (rit != l.rend())
31.         {
32.                 cout << *rit << " ";
33.                 ++rit;
34.         }
35.         cout << endl;
37.         //迭代器不支持 因为 list 迭代器是双向 不支持 + -
38.         /*l.insert(l.begin() + 3);*/
40.         //想要实现第三个位置后插入一个数可以通过下面代码
41.         it = l.begin();
42.         int k = 3;
43.         while (k--)
44.         {
45.                 it++;//支持++
46.         }
47.         l.insert(it, 40);
49.         PrintList(l);
51. }

复制代码

2.3 list 的修改

1. struct A {
2. public:
3.         A(int a1 = 1, int a2 = 1)
4.                 :_a1(a1)
5.                 , _a2(a2)
6.         {
7.                 cout << "A(int a1=1,int a2=1)" << endl;
8.         }
10.         A(const A& aa)
11.                 :_a1(aa._a1)
12.                 , _a2(aa._a2)
13.         {
14.                 cout << "A(const A& aa)" << endl;
15.         }
16. private:
17.         int _a1;
18.         int _a2;
19. };
21. void TestList3()
22. {
23.         int array[] = { 1, 2, 3 };
24.         list<int> L(array, array + sizeof(array) / sizeof(array[0]));
26.         // 在list的尾部插入4，头部插入0
27.         L.push_back(4);
28.         L.push_front(0);
29.         PrintList(L);
31.         // 删除list尾部节点和头部节点
32.         L.pop_back();
33.         L.pop_front();
34.         PrintList(L);
36.         list<A>lt;
37.         A aa1(1, 1);
38.         lt.push_back(aa1);//有名对象尾插
39.         lt.push_back(A(2, 2));//匿名对象尾插
40.         //lt.push_back(3, 3);//不支持 push back只支持一个参数
42.         lt.emplace_back(aa1);
43.         lt.emplace_back(A(2, 2));
44.         cout << endl;
45.         // 前面的插入都是 构造+拷贝构造
47.         // (3,3)的插入 并没有拷贝构造 性能上来说优于 push back
48.         lt.emplace_back(3, 3);//支持 本质支持直接传构造A对象的参数
49. }

复制代码

可以看到 emplace_back 可以支持直接传构造A的参数 省去了临时变量的拷贝构造
插入与删除

1. // insert /erase
2. void TestList4()
3. {
4.         int array1[] = { 1, 2, 3 };
5.         list<int> L(array1, array1 + sizeof(array1) / sizeof(array1[0]));
7.         // 获取链表中第二个节点
8.         auto pos = ++L.begin(); //pos 可以理解为下标
9.         cout << *pos << endl;
11.         // 在pos前插入值为4的元素
12.         L.insert(pos, 4);
13.         PrintList(L);
15.         // 在pos前插入6个值为5的元素
16.         L.insert(pos, 6, 5);
17.         PrintList(L);
19.         // 在pos前插入[v.begin(), v.end)区间中的元素
20.         vector<int> v{ 7, 8, 9 };
21.         L.insert(pos, v.begin(), v.end());
22.         PrintList(L);
24.         // 删除pos位置上的元素
25.         L.erase(pos);
26.         PrintList(L);
28.         // 删除list中[begin, end)区间中的元素，即删除list中的所有元素
29.         L.erase(L.begin(), L.end());
30.         PrintList(L);
31. }

复制代码

1. // resize/swap/clear
2. void TestList5()
3. {
4.         // 用数组来构造list
5.         int array1[] = { 1, 2, 3 };
6.         list<int> l1(array1, array1 + sizeof(array1) / sizeof(array1[0]));
7.         PrintList(l1);
9.         // 交换l1和l2中的元素
10.         list<int> l2;
11.         l1.swap(l2);
12.         PrintList(l1);
13.         PrintList(l2);
15.         // 将l2中的元素清空
16.         l2.clear();
17.         cout << l2.size() << endl;
18. }

复制代码

2.4一些特殊接口

reverse 逆置链表 sort 排序 （算法库里没有list的排序（迭代器不匹配））

1. void test_list4()//容器的 逆置与排序
2. {
3.         list<int>lt;
4.         lt.push_back(1);
5.         lt.push_back(2);
6.         lt.push_back(3);
7.         lt.push_back(4);
8.         lt.push_back(5);
9.         print_list(lt);
10.         lt.reverse();
11.         print_list(lt);
12.         reverse(lt.begin(), lt.end());
13.         print_list(lt);
14.         reverse(++lt.begin(), --lt.end());
15.         print_list(lt);
16.         //算法库里的排序和容器的排序都是默认升序
17.         lt.sort();
18.         print_list(lt);
19.         //想要降序 则需要 仿函数
20.         //less<int>ls;//升序
21.         //greater<int>gt;//降序
22.         //还可以结合匿名对象使用
23.         lt.sort(greater<int>());
24.         print_list(lt);
25. }

复制代码

merge 归并 与 unique 去重（条件均有序链表）

1. void test_list5() // merge有序list合并  unique 有序list去除重复数据
2. {
3.         std::list<double> first, second;
5.         first.push_back(3.1);
6.         first.push_back(2.2);
7.         first.push_back(2.9);
9.         second.push_back(3.7);
10.         second.push_back(7.1);
11.         second.push_back(1.4);
13.         first.sort();
14.         second.sort();
16.         //将 second和first合并 second置为空 前提两list有序
17.         first.merge(second);
18.         print_list(first);
19.         print_list(second);
21.         list<int>lt;
22.         lt.push_back(1);
23.         lt.push_back(2);
24.         lt.push_back(2);
25.         lt.push_back(3);
26.         lt.push_back(3);
27.         lt.push_back(4);
28.         lt.push_back(1);
29.         lt.push_back(1);
30.         print_list(lt);
31.         lt.sort();
32.         //有序的数据去掉重复的数据
33.         lt.unique();
34.         print_list(lt);
35. }

复制代码

剪切拼接 splice 的妙用

1. void test_list6()
2. {
3.         //把一个链表结点转移给另一个链表
4.         std::list<int> mylist1, mylist2;
5.         std::list<int>::iterator it;
7.         // set some initial values:
8.         for (int i = 1; i <= 4; ++i)
9.                 mylist1.push_back(i);      // mylist1: 1 2 3 4
11.         for (int i = 1; i <= 3; ++i)
12.                 mylist2.push_back(i * 10);   // mylist2: 10 20 30
14.         it = mylist1.begin();
15.         ++it;                         // points to 2
16.        
17.         mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
18.                                 // mylist2 (empty)
19.                                // "it" still points to 2 (the 5th element)
20.         print_list(mylist1);
21.         print_list(mylist2);// splice 剪切功能
24.         //splice 还可以调整当前list的顺序
26.         list<int>lt;
27.         lt.push_back(1);
28.         lt.push_back(2);
29.         lt.push_back(3);
30.         lt.push_back(4);
31.         lt.push_back(5);
32.         print_list(lt);
33.         int x = 0;
34.         cin >> x;
35.         it = find(lt.begin(), lt.end(), x);
36.         if (it != lt.end())
37.         {
38.                  // 调整当前链表的元素顺序  将 it指向元素 调整到 begin
39.                 lt.splice(lt.begin(), lt, it);
40.                
41.                 // //迭代器区间
42.                 //lt.splice(lt.begin(), lt, it,lt.end());
43.         }
44.         print_list(lt);
45. }

复制代码

2.5 迭代器失效题目

   前面说过，此处可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。
  因为list的底层结构为带头结点的双向循环链表，因此在 list 中进行插入时是不会导致 list 的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。
  这在 vector 是不创建的，因为 vector 的插入操作有元素移动可能导致重新设置空间，导致原有的迭代器全部失效。

1. void TestListIterator1()
2. {
4.         int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
5.         list<int> l(array, array + sizeof(array) / sizeof(array[0]));
6.         auto it = l.begin();
7.         while (it != l.end())
8.         {
9.                 // erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋值
10.                         l.erase(it);
11.                 ++it;
12.         }
13. }

复制代码

VS2022 对于迭代器失效有着严格的监控机制直接报错

1. // 改正
3. void TestListIterator()
4. {
6.         int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
7.         list<int> l(array, array + sizeof(array) / sizeof(array[0]));
8.         auto it = l.begin();
9.         while (it != l.end())
10.         {
11.                 l.erase(it++);   //it = l.erase(it); erase 返回下一个位置的迭代器
13.         }
14. }

复制代码

这里的 erase 会返回下一个结点的位置

对于 erase(it++); 可以理解为 先it++了再实行erase 代码块里的内容
3、实现list

list 容器的底层是一个带头双向循环链表

• 双向链表的意思是：每个节点不仅存储着数据，还包罗两个指针，分别指向前一个节点和后一个节点。这使得 list 可以在常数时间内进行双向遍历和插入、删除操作。
  
• 库里的节点结构大致如下：
  
• 1. [/code] [align=center][img=1200,287]https://i-blog.csdnimg.cn/direct/3bbd2c7680064d10a9b90766ae381d88.png[/img][/align]
  2. [*] 头节点和尾节点会分别指向 nullptr ，这表明链表的边界。
  3. [/list] 这种双向链表的结构给予了 list 灵动的特性：它可以或许轻松地在恣意位置增长或移除元素，而这种操作险些是与容器大小无关的，体现了时间复杂度上的优势。但这种优势的代价是，[b]与数组相比，List在访问元素时的速度会较慢[/b]，因为它需要从头开始遍历。[b]这也决定了list的更得当频繁插入的动态数据。[/b]
  4. [size=4]3.1底层结构[/size]
  6. [b]根据对链表的理解，我们需要封装一个结点类，为了兼容迭代器的使用，我们需要对结点指针封装一下即迭代器，最后就是实现功能函数的list 类了，我们可以加入一个头结点方便插入删除和兼容容器的左闭右开。[/b]
  7. [hr] [size=3]结点类[/size]
  9. [code]// 结点结构体
  10. template<class T>
  11. struct list_node //默认公有 struct
  12. {
  13.         T _data;
  14.         list_node<T>* _prev;
  15.         list_node<T>* _next;
  17.         list_node(const T& data=T())
  18.                 :_data(data)
  19.                 ,_prev(nullptr)
  20.                 ,_next(nullptr)
  21.         {}
  22.         ~list_node()
  23.         {
  24.                 _next = nullptr;
  25.                 _prev = nullptr;
  26.         }
  27. };

  复制代码
  结点类的结构还是很简单的 结构体里包罗着数据和前后指针即可，因为要多次访问结点以是设置为 struct 较符合
  list类
  
  构造函数需要创建一个头结点，因为我们要创建双向循环链表，以是头尾都要指向头结点本身。 _size统计元素个数。
  
  1. template<class T>
  2. class list
  3. {
  4.         typedef list_node<T> Node;
  6. public:
  7.         typedef list_iterator<T, T&, T*> iterator;
  8.         typedef list_iterator<T, const T&, const T*> const_iterator;
  10.         void empty_init()
  11.         {
  12.                 //_head = new Node;//这里写了 Node 带参数构造 所以报错 需要匿名参数
  13.                 _head = new Node(T());
  14.                 _head->_next = _head;
  15.                 _head->_prev = _head;
  16.                 _size = 0;
  17.         }
  18.         list()
  19.         {
  20.                 empty_init();
  21.         }
  23.         list(initializer_list<T>il)
  24.         {
  25.                 empty_init();
  27.                 for (auto& e : il)
  28.                 {
  29.                         push_back(e);
  30.                 }
  31.                 _size = il.size();
  32.         }
  34. private:
  35.         Node* _head;
  36.         size_t _size;
  37. };

  复制代码
  这里的 list(initializer_list<T>il) 是C++11出现的语法，就可以像数组一样进行初始化了
  迭代器类
  
  list的迭代器显然不是指针！！ 链表的物理地址并不是连续存储的，指针的++ -- 操作是没有意义的，以是我们需要实现一个用结点指针封装的迭代器类，通过运算符重载去模拟指针的行为
  
  
  
  可以看到库里所实现的迭代器类与我们所预想的一致！
  如何实现++ 到下一个结点呢？？
  
  
  通过 重载 ++运算符 获取地址返回下一个结点即可
  迭代器实现：
     
    由于STL list是一个双向链表，迭代器必须具备迁移，后移的本领，以是 list 提供的是 Birdirectional Iterator（双向）
    List 的迭代器
    迭代器有两种实现方式，具体应根据容器底层数据结构实现：
    1. 原生态指针，比如：vector
    2. 将原生态指针进行封装，因迭代器使用形式与指针完全雷同，因此在自定义的类中必须实现以下方法：
    （1）指针可以解引用，迭代器的类中必须重载 operator*()
    （2）指针可以通过->访问其所指空间成员，迭代器类中必须重载 oprator->()
    （3）指针可以++向后移动，迭代器类中必须重载 operator++() 与 operator++(int)
    至于 operator--() / operator--(int) 是否需要重载，根据具体的结构来抉择，双向链表可以向前移动，以是需要重载，如果是forward_list（单向）就不需要重载--
    （4）迭代器需要进行是否相称的比较，因此还需要重载 operator==() 与 operator!=()
  
  1.         template<class T>
  2.         struct list_iterator
  3.         {
  4.                 typedef list_node<T> Node;
  5.                 typedef list_iterator<T> Self;
  7.                 Node* _node;//指针成员变量
  8.                
  9.                 list_iterator(Node* node)
  10.                         :_node(node)
  11.                 {}
  12.                
  13.                 T& operator*()
  14.                 {
  15.                         return _node->_data;
  16.                 }
  18.                 T* operator->()
  19.                 {
  20.                         return &(_node->_data);
  21.                 }
  23.                 //操作符重载 前置++ 与 后置++的区别是参数是否带（int）
  24.                 // ++it
  25.                 Self& operator++()
  26.                 {
  27.                         _node = _node->_next;
  28.                         return *this;
  29.                 }
  31.                 // it++
  32.                 Self& operator++(int x)
  33.                 {
  34.                         Self tmp(*this);//浅拷贝
  35.                         _node = _node->_next;
  36.                         return tmp;
  37.                 }
  38.                
  39.                 //--it
  40.                 Self& operator--()
  41.                 {
  42.                         _node = _node->_prev;
  43.                         return *this;
  44.                 }
  46.                 //it--
  47.                 Self& operator--(int x)
  48.                 {
  49.                         Self tmp(*this);
  50.                         _node = _node->_prev;
  51.                         return tmp;
  52.                 }
  54.                 bool operator!=(const Self& s)const { return _node != s._node; }
  55.                
  56.                 bool operator==(const Self& s)const { return _node == s._node; }
  57.                
  58.         };

  复制代码
  有须要注意的是 重载 -> 是为了适配T为自定义类型的环境
  
  2. list<AA>lta;
  3. lta.push_back(AA());
  4. lta.push_back(AA());
  5. lta.push_back(AA());
  6. lta.push_back(AA());
  7. auto ita = lta.begin();
  8. while (ita != lta.end())
  9. {
  10.         //cout << *ita << ' '; //编译不通过 结构体并没有重载流插入
  11.         //cout << (*ita)._a1         << ' ';
  12.         //cout << ita->_a1 << ' '; //为了可读性省去了一个箭头
  13.         cout << ita.operator->()->_a1 << ' ';
  14.         ++ita;
  15. }

  复制代码
  
  
  
  调用了 operator ->后 AA* 结构体指针再用->调用了_a1
  

  ---

  如许迭代器大致实现了应该有的功能，我们还需要实现一个const 迭代器，如何封装const 迭代器呢？不能修改内容，只需要重载的 * 和 -> 返回类型加上const 修饰即可
  
  
  但是注意到其他重载的运算符都是一样的，如果重新定义一个const 迭代器是否过于冗余呢？
  观察一下STL库里是如何实现的
  
  
  
  显然并不是冗余的复制一份迭代器，而是同一个类模板实现的，实例化两个差别的类，本质上与冗余的写法是一个道理
  
  
  
  那么我们开始优化一下迭代器
  将类模板修改一下
  
  1. //reference 引用  pointer 指针
  2. template<class T , class Ref ,class Ptr>

  复制代码
  有差异的返回值也改变一下
  
  1. Ref operator*() //现在返回const类型还是普通类型是通过编译器推导的
  2. {
  3.         return _node->_data;
  4. }
  6. Ptr operator->()
  7. {
  8.         return &(_node->_data);
  9. }

  复制代码
  那么类实例化的时候传入对应参数编译器就会推导出对应的类：
  
  1. typedef list_iterator<T,T&,T*> iterator;
  2. typedef list_iterator<T,const T&,const T*> const_iterator;

  复制代码
  测试一下
  
  
  
  那么就实现乐成迭代器类模板
  3.2功能接口
  
  迭代器接口
  
  
  1. iterator begin()//第一个结点指针
  2. {
  3.         //iterator it(_head->_next);//构造函数
  4.         //return it; 优化一下
  5.         return _head->_next; //走的隐式类型转换
  6. }
  8. // const 修饰begin 可以兼容拷贝构造 否则出现权限放大 这是不允许的
  9. const_iterator begin()const //前面的const 迭代器是指向元素或引用不可以改变内容 后面的const是修饰this 对象不可以改变
  10. {                                                        //  隐含的this指针由 list * const this 变为 const list* const this 前者是指针不可以更改指向
  11.         return _head->_next;
  12. }
  14. const_iterator cbegin()const
  15. {
  16.         return _head->_next;
  17. }
  19. iterator end()
  20. {
  21.         return _head; // 头节点 左闭右开
  22. }
  24. const_iterator end()const
  25. {
  26.         return _head;
  27. }
  29. const_iterator cend()const
  30. {
  31.         return _head;
  32. }

  复制代码
  const 修饰begin 是为了防止权限放大的错误出现
  
  
  
  因为拷贝构造中参数是 const 对象
  插入删除
  
  由于双向循环，插入删除相对比较简单，就是注意链接的顺序性即可
  
  1. void push_back(const T& x)
  2. {
  3.         //Node* newnode = new Node(x); //没有写Node 构造报错
  4.         //_head->_prev->_next = newnode;
  5.         //newnode->_next = _head;
  6.         //newnode->_prev = _head->_prev;
  7.         //_head->_prev = newnode;
  9.         //++_size;
  10.         insert(end(), x);//复用 insert
  11. }
  13. void push_front(const T& x)
  14. {
  15.         insert(begin(), x);
  16. }
  18. iterator insert(iterator pos, const T& x)
  19. {
  20.         Node* cur = pos._node;
  21.         Node* prev = cur->_prev;
  22.         Node* newnode = new Node(x);
  23.         // prev newnode cur
  24.         newnode->_next = cur;
  25.         cur->_prev = newnode;
  26.         newnode->_prev = prev;
  27.         prev->_next = newnode;
  28.         ++_size;
  30.         return newnode;
  31. }

  复制代码
  实现了 insert 我们可以根据迭代器复用 insert 实现尾插和头插
  TIp：新节点将位于插入点的前一个位置这是STL对于“插入操作”的标准规范。
  

  ---

  删除操作，与 insert 一样使用指针操作，来达到删除的效果。注意要对删除的节点进行释放空间操作（delete），不然会发生内存泄漏！！！
  
  1. void pop_back()
  2. {
  3.         erase(--end());
  4. }
  5. void pop_front()
  6. {
  7.         erase(begin());
  8. }
  9. iterator erase(iterator pos) //防止迭代器失效问题
  10. {
  11.         assert(pos != end());//不可以删除头结点
  12.         Node* prev = pos._node->_prev;;
  13.         Node* next = pos._node->_next;
  15.         prev->_next = next;
  16.         next->_prev = prev;
  18.         delete pos._node;
  19.         --_size;
  20.         return next;
  21. }

  复制代码
  需要注意的是，恣意位置删除因为使用了迭代器，删除后会造成迭代器失效，以是需要更新迭代器，返回被删除节点的下一个节点的迭代器即可。
  拷贝赋值析构函数
  
  
  1. //lt1(lt)
  2. list( const list<T>& lt)
  3. {
  4.         empty_init();
  5.         for (auto& e : lt)
  6.         {
  7.                 push_back(e);
  8.         }
  9. }
  11. void swap(list<T>& lt)
  12. {
  13.         std::swap(_head, lt._head);
  14.         std::swap(_size, lt._size);
  16. }
  18. //lt1=lt3
  19. list<T>& operator=(list<T> lt)
  20. {
  21.         swap(lt);
  22.         return *this;
  23. }
  25. ~list()
  26. {
  27.         clear();
  28.         delete _head;
  29.         _head = nullptr;
  31. }
  33. void clear()
  34. {
  35.         auto it = begin();
  36.         while (it!=end())
  37.         {
  38.                 //erase(it++);//可以这样写 可以理解为 先进行了 it++后再 执行 erase 代码块里的内容
  39.                  it=erase(it);
  40.         }
  41.         _size = 0;
  42. }

  复制代码
  拷贝构造我们只需要范围 for 遍历依次尾插即可，这里空初始化是为了创捷头结点，赋值重载只需要互换头节点就可以
  4、list与vector 区别对比
  
  vector 与 list 都是STL中非常重要的序列式容器，由于两个容器的底层结构差别，导致其特性以及应用场景差别，其主要差别如下：
  
  
  
  
  免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
  
  
  
  

  ---

  欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

  Powered by Discuz! X3.4