0
0

【C++】list基本接口+手撕 list（详解迭代器）

**父母就像迭代器，封装了他们的脆弱...... **

一、list的常用接口及其使用

1.1list 构造函数与增删查改

list 是可以在常数范围内在任意位置进行插入和删除的序列式容器，其底层是带头双向循环链表；list 常用接口的使用和 string、vector 系列容器的接口使用一样，这里我不详细介绍，请看我们的老朋友：cplusplus.com - The C++ Resources Network

构造函数：
构造函数（constructor）接口说明list (size_type n, const value_type& val = value_type())构造的 list 中包含n个值为val的元素list()构造空的 list构造空的 list拷贝构造函数list (InputIterator first, InputIterator last)用 [first, last) 区间中的元素构造 list

**增删查改： **
函数说明接口说明push_front在list首元素前插入值为val的元素pop_front删除list中第一个元素push_back在list尾部插入值为val的元素pop_back删除list中最后一个元素insert在list position 位置中插入值为val的元素erase删除list position位置的元素swap交换两个list中的元素clear清空list中的有效元素
注意：

1、由于 list 的物理结构是非连续的 – 前一个节点地址和后一个节点地址的位置关系是随机的，所以 list 不支持随机访问，自然也就不支持 [ ] 操作；

2、list 不支持reserve操作，因为 list 的节点是使用时开辟，使用完销毁，不能预留空间；

（从这个特点也容易看出来，如果需要一直插入删除元素，利用list更好）

1.2list 特殊接口

除了上述 STL 容器基本都有的一般接口外，list 还提供一些独有的特殊操作接口，如下：
函数声明接口说明splice将 list1 中的元素转移到 list2 中remove移除 list 中的指定元素unique链表去重（sort之后才可以用）merge合并两个链表sort链表排序（探究为什么list自己写sort）reverse链表逆置
题外话： 为什么list需要自己实现sort接口？？难道说库中的封装性不好？效率不高？

我们先使用库中自己的sort函数：

我们使用算法库中的sort函数：

  1. void test_sort()
  2. {
  3.      list<int> l1{ 5,6,4,8,9,2,7 };//C++ 11写法
  4.      sort(l1.begin(),l1.end());
  5.      for(auto l : l1)
  6.      {
  7.         cout << l << " ";
  8.      }
  9.      cout << endl;
  10. }

报错了（意外之中，如果不报错我还写这个知识点干啥 doge） 报错原因说没有-迭代器

让我们看看sort源码~

**这一切的一切都是因为sort的迭代器引起的！！ **

注意：

1、链表排序只能使用 list 提供的 sort 接口，而不能使用 algorithm 提供的 sort 接口，因为链表物理地址不连续，迭代器为双向迭代器，不支持 + - 操作，而算法库中的 sort 函数需要支持 + - 的随机迭代器；

2、链表去重之前必须保证链表有序，否则去重不完全；

3、两个有序链表合并之后仍然保存有序；

最后，虽然 list 提供了这些具有特殊功能的接口，它们也确实有一定的作用，但是实际上这些特殊接口使用频率非常低，包括 sort 接口 (链表排序的效率太低)。

1.3list 排序性能分析

虽然链表排序只能使用 list 提供的 sort 接口，而不能使用 algorithm 提供的 sort 接口，但是其使用频率仍然非常低，这是由于链表排序的效率太低了，我们可以通过对比两组测试数据来直观的感受链表排序的效率。

测试一：vector 排序与 list 排序性能对比

  1. //vector sort 和 list sort 性能对比 -- release 版本下
  2. void test_op1() {
  3.     srand((size_t)time(0));
  4.     const int N = 1000000;  //100万个数据
  6.     vector<int> v;
  7.     v.reserve(N);
  8.     list<int> lt;
  9.     for (int i = 0; i < N; ++i)
  10.     {
  11.         auto e = rand();
  12.         v.push_back(e);
  13.         lt.push_back(e);
  14.     }
  16.     //vector sort
  17.     int begin1 = clock();
  18.     sort(v.begin(), v.end());
  19.     int end1 = clock();
  21.     //list sort
  22.     int begin2 = clock();
  23.     lt.sort();
  24.     int end2 = clock();
  26.     printf("vector sort:%d\n", end1 - begin1);
  27.     printf("list sort:%d\n", end2 - begin2);
  28. }

测试二：list 直接进行排序与将数据拷贝到 vector 中使用 vector 排序后再将数据拷回 list 中性能对比

  1. //list sort 与 将数据转移到 vector 中进行排序后拷贝回来性能对比 -- release 版本下
  2. void test_op2()
  3. {
  4.     srand(time(0));
  5.     const int N = 1000000;  //100万个数据
  6.     list<int> lt1;
  7.     list<int> lt2;
  8.     for (int i = 0; i < N; ++i)
  9.     {
  10.         auto e = rand();
  11.         lt1.push_back(e);
  12.         lt2.push_back(e);
  13.     }
  15.     //list sort -- lt1
  16.     int begin1 = clock();
  17.     lt1.sort();
  18.     int end1 = clock();
  20.     // 将数据拷贝到vector中排序，排完以后再拷贝回来 -- lt2
  21.     int begin2 = clock();
  22.     vector<int> v;
  23.     v.reserve(N);
  24.     for (auto e : lt2)  //拷贝
  25.     {
  26.         v.push_back(e);
  27.     }
  28.     sort(v.begin(), v.end());  //排序
  29.     lt2.assign(v.begin(), v.end());  //拷贝
  30.     int end2 = clock();
  32.     printf("list1 sort:%d\n", end1 - begin1);
  33.     printf("list2 sort:%d\n", end2 - begin2);
  34. }

可以看到，list sort 的效率远低于 vector sort，甚至于说，直接使用 list sort 的效率都不如先将数据拷贝到 vector 中，然后使用 vector sort，排序之后再将数据拷贝回 list 中快；所以list中的sort接口是很挫的！！

二、list 迭代器实现（重点+难点）

关于迭代器的引入知识：

迭代器的价值在于封装底层的实现，不具体暴露底层的实现细节，提供统一的访问方式

iterator只是代言人！！真正的牛逼大佬其实是_list_iterator

为什么在 list 中将迭代器搞成指针这招不好用了呢？？

在数组中，指针就是元素，指针++就是 +sizeof(T) 对象大小，没办法，谁叫他们物理空间连续，结构NB，所以对于vector和string类而言，物理空间是连续的，原生的指针就是迭代器了，解引用就是数据了。*但是对于这里的list而言，空间是不连续的

解决方法：

此时如果解引用是拿不到数据的（空间不连续），更不用说++指向下一个结点了。所以，对于list的迭代器，原生指针已经不符合我们的需求了，我们需要去进行特殊处理：进行类的封装。我们可以通过类的封装以及运算符重载支持，这样就可以实现像内置类型一样的运算符

迭代器的俩个特征：

1.解引用2.++ / --

运算符重载的大任务：

实现解引用operator*（）和++函数

2.1迭代器的分类

按照迭代器的功能，迭代器一共可以分为以下三类：

  • 单向迭代器 – 迭代器仅仅支持 ++ 和解引用操作（单链表，哈希）

  • 双向迭代器 – 迭代器支持 ++、-- 和解引用操作，但不支持 +、- 操作（list 双向链表）

  • 随机迭代器 – 迭代器不仅支持 ++、-- 和解引用操作，还支持 +、- 操作，即迭代器能够随机访问（string，vector）

这也充分说明，vector和string是可以用库中的sort函数的

​

迭代器还可以分成普通迭代器和const迭代器俩类：

  1. //1.const T* p1
  2. list<int>::const_iterator cit = lt.begin();
  3. //2.T* const p2
  4. const list<int>::iterator cit = lt.begin();
  5. //不符合const迭代器的行为，因为保护迭代器本身不能修改，那么我们也就不能++迭代器

灵魂拷问：const迭代器是p1还是p2？p1

const迭代器类似p1的行为，保护指向的对象不被修改，迭代器本身可以修改

2.2 list 迭代器失效问题（和vector有差异）

vector迭代器失效：insert扩容+erase的时候会失效

和 vector 不同，list 进行 insert 操作后并不会产生迭代器失效问题，因为 list 插入的新节点是动态开辟的，同时由于 list 每个节点的物理地址是不相关的，所以插入的新节点并不会影响原来其他节点的地址；

但是 list erase 之后会发生迭代器失效，因为 list 删除节点会直接将该节点释放掉，此时我们再访问该节点就会造成越界访问

2.3list 迭代器源码模板

我们知道，迭代器是类似于指针一样的东西，即迭代器要能够实现指针相关的全部或部分操作 – ++、–、*、+、-；对我们之前 string 和 vector 的迭代器来说，迭代器就是原生指针，所以它天然的就支持上述操作；

但是对于 list 来说，list 的节点是一个结构体，同时 list 每个节点的物理地址是不连续的，如果此时我们还简单将节点的指针 typedef 为迭代器的话，那么显然它是不能够实现解引用、++ 等操作的，所以我们需要用结构体/类来对迭代器进行封装，再配合运算符重载等操作让迭代器能够实现解引用、++、-- 等操作

框架代码如下：

  1. //节点定义
  2. template <class T>
  3. struct __list_node {
  4.     typedef void* void_pointer;
  5.     void_pointer next;
  6.     void_pointer prev;
  7.     T data;
  8. };
  10. //迭代器定义
  11. typedef __list_iterator<T, T&, T*>   iterator;
  12. typedef __list_iterator<T, const T&, const T*>  const_iterator;
  14. //迭代器类
  15. template<class T, class Ref, class Ptr>
  16. struct __list_iterator {
  17.      typedef __list_iterator<T, Ref, Ptr>  self;
  18.      typedef __list_node<T>* link_type;  //节点的指针
  19.      link_type node; //类成员变量
  20.     
  21.      __list_iterator(link_type x) : node(x) {} //将节点指针构造为类对象
  22.     
  23.     //... 使用运算符重载支持迭代器的各种行为
  24.     self& operator++() {...}
  25.     self& operator--() {...}
  26.     Ref operator*() const {...}
  27. };

2.4list 整体基本框架

  1. namespace lzy
  2. {
  3.     //结点
  4.     template<class T>
  5.     struct list_node
  6.     {
  7.         list_node* _next;
  8.         list_node* _prev;
  9.         T _data;
  11.         list_node(const T& x)//节点的构造函数及初始化列表
  12.             :_next(nullptr)
  13.             , _prev(nullptr)
  14.             , _data(x)
  15.         {}
  16.     };
  18.     template<class T>
  19.     class list
  20.     {
  21.         typedef list_node<T> node;
  22.     public:
  23.         //迭代器
  24.         typedef __list_iterator<T> iterator;
  25.         typedef __list_const_iterator<T> const_iterator;
  26.         //构造
  27.         list()
  28.         {
  29.             _head = new node(T());
  30.             _head->_next = _head;
  31.             _head->_prev = _head;
  32.         }
  33.     private:
  34.         node* _head;
  35.         size_t _size;
  36.     };
  37. }

三、手撕list迭代器

迭代器的实现我们需要去考虑普通迭代器和const迭代器。这两种迭代器的不同，也会带来不同的接口。我们可以分别单独去进行实现，我们先来看一看简单的构造迭代器，只需要提供一个结点即可,看一看实现的基本框架：

  1.     template<class T>
  2.     struct __list_iterator
  3.     {
  4.         typedef list_node<T> node;
  5.         node* _pnode;
  7.         __list_iterator(node* p)
  8.             :_pnode(p)
  9.         {}
  10.     }

为什么迭代器不写拷贝构造函数？浅拷贝真的可以吗？

对于迭代器的拷贝构造和赋值重载我们并不需要自己去手动实现，编译器默认生成的就是浅拷贝，而我们需要的就是浅拷贝，这也说明了，并不是说如果有指针就需要我们去实现深拷贝，而且迭代器不需要写析构函数，所以说不需要深拷贝

为什么聊这个问题？因为list<int>::iterator it=v.begin() 这就是一个拷贝构造

3.1重载operator*()

这个比较简单，就是要获取迭代器指向的数据，并且返回数据的引用：

  1. T& operator*()
  2. {
  3.     return _pnode->_data;
  4. }

3.2重载++、–、！=

  1.        __list_iterator<T>& operator++()
  2.         {
  3.             _pnode = _pnode->_next;
  4.             return *this;
  5.         }
  7.         __list_iterator<T>& operator--()
  8.         {
  9.             _pnode = _pnode->_prev;
  10.             return *this;
  11.         }
  13.         bool operator!=(const __list_iterator<T>& it)
  14.         {
  15.             return _pnode != it._pnode;
  16.         }

如果按照上面的做法，我们在来看看此时普通迭代器和const迭代器的区别：

  1. //typedef __list_iterator<T> iterator;
  2. //typedef __list_const_iterator<T> const_iterator;
  3.     template<class T>
  4.     struct __list_iterator
  5.     {
  6.         typedef list_node<T> node;
  7.         node* _pnode;
  9.         __list_iterator(node* p)
  10.             :_pnode(p)
  11.         {}
  13.         T& operator*()
  14.         {
  15.             return _pnode->_data;
  16.         }
  18.         __list_iterator<T>& operator++()
  19.         {
  20.             _pnode = _pnode->_next;
  21.             return *this;
  22.         }
  24.         __list_iterator<T>& operator--()
  25.         {
  26.             _pnode = _pnode->_prev;
  27.             return *this;
  28.         }
  30.         bool operator!=(const __list_iterator<T>& it)
  31.         {
  32.             return _pnode != it._pnode;
  33.         }
  34.     };
  36.     //跟普通迭代器的区别：遍历，不能用*it修改数据
  37.     template<class T>
  38.     struct __list_const_iterator
  39.     {
  40.         typedef list_node<T> node;
  41.         node* _pnode;
  43.         __list_const_iterator(node* p)
  44.             :_pnode(p)
  45.         {}
  47.         const T& operator*()
  48.         {
  49.             return _pnode->_data;
  50.         }
  52.         __list_const_iterator<T>& operator++()
  53.         {
  54.             _pnode = _pnode->_next;
  55.             return *this;
  56.         }
  58.         __list_const_iterator<T>& operator--()
  59.         {
  60.             _pnode = _pnode->_prev;
  61.             return *this;
  62.         }
  64.         bool operator!=(const __list_const_iterator<T>& it)
  65.         {
  66.             return _pnode != it._pnode;
  67.         }
  68.     };

代码冗余！！！代码冗余！！！代码冗余！！！

如果是这样子去实现的话，我们就会发现，这两个迭代器的实现并没有多大的区别，唯一的区别就在于operator*的不同。const迭代器和普通迭代器的唯一区别就是普通迭代器返回T&，可读可写，const迭代器返回const T&,可读不可写。我们可以参考源码的实现：类模板参数解决这个问题，这也是迭代器的强大之处

3.3 利用类模板优化

  1. template <class T,class Ref,class Ptr>
  2. //typedef __list_iterator<T, T&, T*> iterator;
  3. //typedef __list_iterator<T, const T&, const T*> const_iterator;

利用类模板参数修正之后的代码：

  1.     //  typedef __list_iterator<T, T&, T*> iterator;
  2.     //  typedef __list_iterator<T, const T&, const T*> const_iterator;
  3.     template<class T, class Ref, class Ptr>
  4.     struct __list_iterator
  5.     {
  6.         typedef list_node<T> node;
  7.         typedef __list_iterator<T, Ref, Ptr> Self;
  8.         node* _pnode;
  9.         __list_iterator(node*p)
  10.             :_pnode(p)
  11.         {
  12.         }
  13.         //返回数据的指针
  14.         Ptr operator->()
  15.         {
  16.             return &_pnode->_data;
  17.         }
  18.         //模板参数做返回值
  19.         Ref operator *()
  20.         {
  21.             return _pnode->_data;
  22.         }
  24.         //++it
  25.         Self& operator ++()
  26.         {
  27.             _pnode = _pnode->_next;
  28.             return *this;
  29.         }
  31.         //it++
  32.         Self operator ++(int)
  33.         {
  34.             Self tmp(*this);
  35.             _pnode = _pnode->_next;
  36.             return tmp;
  37.         }
  39.         Self& operator--()
  40.         {
  41.             _pnode = _pnode->_prev;
  42.             return *this;
  43.         }
  45.         Self operator--(int)
  46.         {
  47.             Self tmp(*this);
  48.             _pnode = _pnode->_prev;
  49.             return tmp;
  50.         }
  52.         bool operator !=(const Self& it)const
  53.         {
  54.             return _pnode != it._pnode;
  55.         }
  57.         bool operator ==(const Self& it)const
  58.         {
  59.             return _pnode == it._pnode;
  60.         }
  61.     };

同一个类模板，此时我们传递不同的参数实例化成不同的迭代器了！！！这解决了我们刚刚所说的代码冗余问题

四、增删查改

4.1 insert（参数必须加引用，担心非内置类型）和erase

insert：在pos位置上一个插入，返回插入位置的迭代器，对于list的insert迭代器不会失效，vector失效是因为扩容导致pos位置造成野指针问题

  1.         iterator insert(iterator pos,const T& x)
  2.         {
  3.             node* newnode = new node(x);
  4.             node* cur = pos._pnode;
  5.             node* prev = cur->_prev;
  7.             newnode->_prev = prev;
  8.             prev->_next = newnode;
  9.             newnode->_next = cur;
  10.             cur->_prev = newnode;
  12.             ++_size;
  13.             return iterator(newnode);
  14.         }

erase:这里的带头（哨兵位）头结点不可删除，返回值是删除位置的下一个，对于list的erase迭代器是失效的

  1.         iterator erase(iterator pos)
  2.         {
  3.             assert(pos != end());
  4.             node* prev = pos._pnode->_prev;
  5.             node* next = pos._pnode->_next;
  7.             prev->_next = next;
  8.             next->_prev = prev;
  9.             delete pos._pnode;
  10.             --_size;
  11.             return iterator(next);
  12.         }

4.2 push_back和push_front

  1.         void push_back(const T& x)
  2.         {
  3.             insert(end(), x);
  4.         }
  6.         void push_front(const T& x)
  7.         {
  8.             insert(begin(), x);
  9.         }

注意！list的begin和end的位置

同时这个问题还可以延伸出另一个问题：为什么迭代器访问元素的时候要这样写？

在vector中，物理地址是连续的，这么写还情有可原，分析过list的begin和end之后，你还敢这么写吗？？

直接就报错了，所以正确的应该是！=，而不是 <

  1. void test3()
  2. {
  3.     vector<int> vv={1,5,7,8,9,3,4};
  4.     list<int> l={1,5,6,7};
  5.     vector<int>::iterator it1=vv.begin();
  6.     list<int>::iterator it2=l.begin();
  7.     while(it1 < vv.end())
  8.     {
  9.         cout << *it1 << " ";
  10.         it1++;
  11.     }
  12.     cout << endl;
  13.     // while(it2 < l.end())
  14.     // {
  15.     //     cout << *it2 << " ";
  16.     //     it2++;
  17.     // }
  18.     while(it2 != l.end())
  19.     {
  20.         cout << *it2 << " ";
  21.         it2++;
  22.     }
  23.     cout << endl;
  24. }

4.3 pop_back和pop_front

尾删和头删，复用erase即可

  1.         void pop_front()
  2.         {
  3.             erase(begin());
  4.         }
  6.         void pop_back()
  7.         {
  8.             erase(--end());
  9.         }

这里的尾删刚好用上了我们的重载

五、list 构造+赋值重载

5.1默认构造+迭代器区间构造+拷贝构造

默认构造：

  1. list()
  2. {
  3.     _head = new node(T());
  4.     _head->_next = _head;
  5.     _head->_prev = _head;
  6.     _size = 0;
  7. }

我们可以用empty_initialize()来封装初始化，方便复用，不用每次都写：

  1. void empty_initialize()
  2. {
  3.     _head = new node(T());
  4.     _head->_next = _head;
  5.     _head->_prev = _head;
  6.     _size = 0;
  7. }

迭代器区间构造：

  1.         //迭代器区间构造
  2.         template <class InputIterator>
  3.         list(InputIterator first, InputIterator last)
  4.         {
  5.             empty_initialize();
  6.             while (first != last)
  7.             {
  8.                 push_back(*first);
  9.                 ++first;
  10.             }
  11.         }

拷贝构造：

传统：

  1.         list(const list<T>& lt)
  2.         {
  3.             empty_initialize();
  4.             for (const auto& e : lt)
  5.             {
  6.                 push_back(e);
  7.             }
  8.         }

用范围for进行尾插，但是要注意要加上&，范围for是*it赋值给给e，又是一个拷贝，e是T类型对象，依次取得容器中的数据，T如果是string类型，不断拷贝，push_back之后又销毁

现代：

  1.         void swap(list<T>& lt)
  2.         {
  3.             std::swap(_head, lt._head);
  4.             std::swap(_size, lt._size);
  5.         }        
  6.         list(const list<T>& lt)
  7.         {
  8.             empty_initialize();
  9.             list<T> tmp(lt.begin(), lt.end());
  10.             swap(tmp);
  11.         }

5.2 赋值重载现代写法

  1.         list<T>& operator=(list<T> lt)
  2.         {
  3.             swap(lt);
  4.             return *this;
  5.         }

5.3 类名和类型的问题（C++的一个坑）

查看官方文档，我们可以看到list没有类型：

**list<T>& operator=(list<T> lt)
list& operator=(list lt) **

对于普通类：类名等价于类型

对于类模板：类名不等价于类型（如list模板，类名：list 类型：list）

类模板里面可以用类名代表类型，但是并不建议，在类外面则必须要带模板参数list

六、list和vector的对比（重点）

vectorlist底层结构动态顺序表，一段连续空间带头结点的双向循环链表随机访问支持随机访问，访问某个元素效率 O(1)不支持随机访问插入和删除任意位置插入和删除效率低，需要搬移元素，时间复杂度为 O(N)，插入时有可能需要增容，增容：开辟新空间，拷贝元素，释放旧空间，导致效率更低任意位置插入和删除效率高，不需要搬移元素，时间复杂度为 O(1)空间利用率底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低迭代器原生态指针对原生态指针 (节点指针) 进行封装迭代器失效在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响使用场景在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效大量插入和删除操作，不关心随机访问

七、源码合集

  1. #pragma once
  3. #include <iostream>
  4. #include <assert.h>
  5. #include <algorithm>
  7. namespace lzy {
  8.     template<class T>
  9.     struct list_node  //list 节点结构定义
  10.     {
  11.         list_node<T>* _next;//不加<T>也没错，但是写上好一些
  12.         list_node<T>* _prev;
  13.         T _data;
  15.         list_node(const T& x)//构造
  16.             :_next(nullptr)
  17.             , _prev(nullptr)
  18.             , _data(x)
  19.         {}
  20.     };
  22.     //迭代器最终版
  23.     //const 迭代器 -- 增加模板参数，解决 operator*() 返回值与 operator->() 返回值问题
  24.     //typedef __list_iterator<T, T&, T*> iterator;
  25.     //typedef __list_iterator<T, const T&, const T*> const_iterator;
  26.     //STL源码中大佬的写法，利用多个模板参数来避免副本造成的代码冗余问题
  27.     template<class T, class Ref, class Ptr>
  28.     struct __list_iterator  //迭代器类
  29.     {
  30.         typedef list_node<T> node;  //重命名list节点
  31.         typedef __list_iterator<T, Ref, Ptr> Self;  //这里进行重命名是为了后续再添加模板参数时只用修改这一个地方
  32.         node* _pnode;  //节点指针作为类的唯一成员变量
  34.         __list_iterator(node* p)
  35.             :_pnode(p)
  36.         {}
  38.         Ref operator*()  //解引用
  39.         {
  40.             return _pnode->_data;
  41.         }
  43.         Ptr operator->()  //->
  44.         {
  45.             return &_pnode->_data;
  46.         }
  48.         Self& operator++() //前置++
  49.         {
  50.             _pnode = _pnode->_next;
  51.             return *this;
  52.         }
  54.         Self& operator++(int) //后置++
  55.         {
  56.             Self it(*this);
  57.             _pnode = _pnode->_next;
  58.             return it;
  59.         }
  61.         Self& operator--() //前置--
  62.         {
  63.             _pnode = _pnode->_prev;
  64.             return *this;
  65.         }
  67.         Self& operator--(int) //后置--
  68.         {
  69.             Self it(*this);
  70.             _pnode = _pnode->_prev;
  71.             return it;
  72.         }
  74.         bool operator!=(const Self& it) const //!=
  75.         {
  76.             return _pnode != it._pnode;
  77.         }
  79.         bool operator==(const Self& it) const  //==
  80.         {
  81.             return _pnode == it._pnode;
  82.         }
  83.     };
  85.     //list 类
  86.     template<class T>
  87.     class list
  88.     {
  89.         typedef list_node<T> node;  //list 的节点
  90.     public:
  91.         typedef __list_iterator<T, T&, T*> iterator;  //迭代器
  92.         typedef __list_iterator<T, const T&, const T*> const_iterator; //const 迭代器
  94.         //迭代器
  95.         iterator begin() {
  96.             return iterator(_head->_next);
  97.         }
  99.         iterator end() {
  100.             //iterator it(_head);
  101.             //return it;
  103.             //直接利用匿名对象更为便捷
  104.             return iterator(_head);
  105.         }
  107.         const_iterator begin() const {
  108.             return const_iterator(_head->_next);
  109.         }
  111.         const_iterator end() const {
  112.             return const_iterator(_head);
  113.         }
  115.         void empty_initialize() {  //初始化 -- 哨兵位头结点
  116.             _head = new node(T());
  117.             _head->_next = _head;
  118.             _head->_prev = _head;
  120.             _size = 0;  //空间换时间，用于标记节点个数
  121.         }
  123.         list() {  //构造，不是list<T>的原因：构造函数函数名和类名相同，而list<T>是类型
  124.             empty_initialize();
  125.         }
  127.         //迭代器区间构造
  128.         template <class InputIterator>
  129.         list(InputIterator first, InputIterator last) {
  130.             empty_initialize();
  131.             while (first != last)
  132.             {
  133.                 push_back(*first);
  134.                 ++first;
  135.                 //first++;
  136.             }
  137.         }
  139.         //拷贝构造传统写法
  140.         //list(const list<T>& lt) {
  141.         //    empty_initialize();
  143.         //    for (const auto& e : lt)
  144.         //    {
  145.         //        push_back(e);
  146.         //    }
  147.         //}
  149.         // 拷贝构造的现代写法
  150.         //list(const list& lt) 官方库是这样写的，这是由于在类内类名等价于类型，但不建议自己这样写
  151.         list(const list<T>& lt) {
  152.             empty_initialize();  //初始化头结点，防止交换后tmp野指针不能正常的调用析构
  153.             list<T> tmp(lt.begin(), lt.end());
  154.             swap(tmp);
  155.         }
  157.         //赋值重载传统写法
  158.         //list<T>& operator=(const list<T>& lt) {
  159.         //    if (this != &lt)
  160.         //    {
  161.         //        clear();
  162.         //        for (const auto& e : lt)
  163.         //        {
  164.         //            push_back(e);
  165.         //        }
  166.         //    }
  167.         //    return *this;
  168.         //}
  170.         //赋值重载现代写法
  171.         //list& operator=(list lt)
  172.         list<T>& operator=(list<T> lt) {  //不能加引用，lt是调用拷贝构造生成的
  173.             swap(lt);
  174.             return *this;
  175.         }
  177.         ~list() {  //析构
  178.             clear();
  179.             delete _head;
  180.             _head = nullptr;
  181.         }
  183.         void swap(list<T>& lt) {  //交换两个链表，本质上是交换两个链表的头结点
  184.             std::swap(_head, lt._head);
  185.             std::swap(_size, lt._size);
  186.         }
  188.         size_t size() const {  //增加一个计数的成员，以空间换时间
  189.             return _size;
  190.         }
  192.         bool empty() {  //判空
  193.             return _size == 0;
  194.         }
  196.         void clear() {
  197.             iterator it = begin();
  198.             while (it != end()) {
  199.                 it = erase(it);
  200.             }
  201.             _size = 0;
  202.         }
  204.         void push_back(const T& x) {
  205.             //node* newnode = new node(x);
  206.             //node* tail = _head->_prev;
  207.             //tail->_next = newnode;
  208.             //newnode->_prev = tail;
  209.             //newnode->_next = _head;
  210.             //_head->_prev = newnode;
  212.             insert(end(), x);  //复用
  213.         }
  215.         void push_front(const T& x) {
  216.             insert(begin(), x);  //复用
  217.         }
  219.         void pop_front() {
  220.             erase(begin());
  221.         }
  223.         void pop_back() {
  224.             erase(--end());
  225.         }
  227.         iterator insert(iterator pos, const T& x) {
  228.             node* newnode = new node(x);
  229.             node* cur = pos._pnode;
  230.             node* prev = cur->_prev;
  232.             prev->_next = newnode;
  233.             newnode->_prev = prev;
  234.             cur->_prev = newnode;
  235.             newnode->_next = cur;
  237.             ++_size;
  238.             return iterator(pos);
  239.         }
  241.         iterator erase(iterator pos) {
  242.             assert(pos != end());
  244.             node* prev = pos._pnode->_prev;
  245.             node* next = pos._pnode->_next;
  247.             prev->_next = next;
  248.             next->_prev = prev;
  249.             delete pos._pnode;
  251.             --_size;
  252.             return iterator(next);
  253.         }
  255.     private:
  256.         node* _head;
  257.         size_t _size;
  258.     };
  259. }

完结撒花~

标签： c++ stl
本文转载自: https://blog.csdn.net/weixin_62985813/article/details/133713234
版权归原作者 小羊oi！ 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【C++】list基本接口+手撕 list（详解迭代器）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？