目录
1. list的介绍及使用
1.1 list的介绍
1. list 是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。2. list 的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list 与 forward_list 非常相似：最主要的不同在于 forward_list 是单链表，只能朝前迭代，已让其更简单高效。4. 与其他的序列式容器相比 (array ， vector ， deque) ， list 通常在任意位置进行插入、移除元素的执行效率更好。5. 与其他序列式容器相比， list 和 forward_list 最大的缺陷是不支持任意位置的随机访问，比如：要访问 list的第6 个元素，必须从已知的位置 ( 比如头部或者尾部 ) 迭代到该位置，在这段位置上迭代需要线性的时间开销；list 还需要一些额外的空间，以保存每个节点的相关联信息 ( 对于存储类型较小元素的大 list 来说这可能是一个重要的因素)list的大致的结构：
1.2 list的使用
因为接口和vector很相似，这里只介绍重点：
1.2.1 list的构造
list
中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展 的能力。以下为list
中一些
常见的重要接口
1.2.2 list iterator的使用
注意：
1.
begin与end
为正向迭代器，对迭代器
执行++操作，迭代器向后移动
2.
rbegin(end)与rend(begin)
为反向迭代器，对
迭代器执行++操作，迭代器向前移动
这是C++中最常用的遍历方式，因为有了迭代器，所有的数据结构都可以用这种方式进行遍历，这体现了C++的封装性。注意这里的iterator不是一个原生指针，而是对其进行了封装。（后面模拟实现再来感受）
1.2.3 list capacity
1.2.4 list element access
1.2.5 list modififiers
这里要提一下的是swap函数的使用问题：
这里list专门提供了一个swap函数用于交换，但是这个函数实际上并没有什么用处，因为其效率非常低，甚至不如把list中的数据拷贝到vector中，然后排完再存到list中的效率高，所以这样来看，这个接口基本用处不大，少量的数据的时候才能使用。下面看测测swap的性能如何；
void test_op() { srand(time(0)); const int N = 1000000; vector<int> v; v.reserve(N); list<int> lt1; list<int> lt2; for (int i = 0; i < N; ++i) { auto e = rand(); v.push_back(e); //lt1.push_back(e); lt2.push_back(e); } 拷贝到vector排序，排完以后再拷贝回来 int begin1 = clock(); //for (auto e : lt1) //{ // v.push_back(e); //} sort(v.begin(), v.end()); //size_t i = 0; //for (auto& e : lt1) //{ // e = v[i++]; //} int end1 = clock(); int begin2 = clock(); // sort(lt.begin(), lt.end()); lt2.sort(); int end2 = clock(); printf("vector sort:%d\n", end1 - begin1); printf("list sort:%d\n", end2 - begin2); }vector和list排序的速度对比：
可以看到vector比list快了2倍。
下面看看把list数据放到vector中排序然后再放回list中的对比：
对比以上情景，确实证明了list排序不是一个良好的排序，所以list里面的sort要慎用。
当数据到了一千万时，这个差距更加大：
1.2.6 list的迭代器失效
迭代器失效即迭代器所指向的节点的无效，即该节 点被删除了 。因为 list 的底层结构为带头结点的双向循环链表 ，因此 在 list 中进行插入时是不会导致 list 的迭代 器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响 。（这是基于list的非连续地址的原因）
正确的写法：
因为这里erase删除后会返回下个元素的迭代器，所有不需要++。
2. list的模拟实现（重难点）
在模拟实现之前，我们要清楚我们要使用3个类：一个是节点类，一个迭代器类，一个list类。这里为什么要使用迭代器类呢？很重要的一个原因在于迭代器如果使用原生指针的话，就不适合list的空间结构了，原生指针++就是4个字节，显然list类的节点++的结果是不确定的。我们要使用每个节点中存储的下一个节点的地址来进行++。如果我们像C语言中实现双向带头循环链表一样就失去了封装性，还有stl中使用迭代器的方式就是为了让每一种容器都能使用迭代器的方式进行遍历。
下面我们来看看这三个类：
节点类：
//节点类 template<class T> struct ListNode { ListNode(const T& x) :_val(x) , _pre(nullptr) , _next(nullptr) {} ListNode<T>* _pre; ListNode<T>* _next; T _val; };节点类比较简单就是两个地址，一个数据。另外提供构造函数进行初始化。
迭代器类：（难点）：
首先要明确迭代器类的作用，就是在list类中进行迭代器的++或者其他操作时我们可以将其转换为一个函数调用。 这就是运算符重载的作用，实现了封装性。
还有一个很大的问题就是在实现const迭代器和普通迭代器的时候：
我们就会发现一个问题：就是我们怎么样能让普通的迭代器调用普通的迭代器的运算符重载，而const迭代器调用const迭代器的运算符重载呢？用正常的方式不可能在同一类里面实现，因为函数重载的类型是不包括参数不同的。如果像下面的做法确实是可以做到的：
template<class T> struct __list_iterator { typedef list_node<T> node; node* _pnode; __list_iterator(node* p) :_pnode(p) {} // iterator it // *it // ++it; T& operator*() { return _pnode->_data; } // const iterator cit // *cit // ++cit 这样的话，可以解引用，但是不能++ /*const T& operator*() const { return _pnode->_data; }*/ __list_iterator<T>& operator++() { _pnode = _pnode->_next; return *this; } __list_iterator<T>& operator--() { _pnode = _pnode->_prev; return *this; } bool operator!=(const __list_iterator<T>& it) { return _pnode != it._pnode; } }; // 跟普通迭代器的区别：遍历，不能用*it修改数据 template<class T> struct __list_const_iterator { typedef list_node<T> node; node* _pnode; __list_const_iterator(node* p) :_pnode(p) {} const T& operator*() { return _pnode->_data; } __list_const_iterator<T>& operator++() { _pnode = _pnode->_next; return *this; } __list_const_iterator<T>& operator--() { _pnode = _pnode->_prev; return *this; } bool operator!=(const __list_const_iterator<T>& it) { return _pnode != it._pnode; } };但是不觉得这样写代码冗余吗？
为此设计stl的大佬们就使用了多个模板参数来解决这个问题：
//迭代器类 template <class T, class Ref , class Ptr> class List_iterator { typedef List_iterator<T,Ref,Ptr> Self; typedef ListNode<T> node; public: List_iterator(node* _pnode) :_Node(_pnode) {} Ptr operator->() { return &(_Node->val); } Ref operator*() { return _Node->_val; } Self& operator++() { _Node = _Node->_next; return *this; } Self& operator++(int) { Self tmp(*this); _Node = _Node->_next; return tmp; } Self& operator--() { _Node = _Node->_pre; return *this; } Self& operator--(int) { Self tmp(*this); _Node = _Node->_pre; return tmp; } bool operator!=(const Self& it) { return _Node != it._Node; } bool operator==(const Self& it) { return _Node == it._Node; } node* _Node; };这样const迭代器的问题就能很好的解决了。
下面我们看看list类：
list类还是比较简单的，和C语言实现的双向循环带头链表的方式没有很大的差异
//list类 template<class T> class list { public: typedef List_iterator<T,T& ,T*> iterator; typedef List_iterator<T ,const T& ,const T*> const_iterator; typedef ListNode<T> node; public: //构造 list() { CreateHead(); _sz = 0; } 传统写法 //list(const list<T>& l) //{ // CreateHead(); // for (const auto& e : l) // { // push_back(e); // } //} //现代写法 list(const list<T>& l) { CreateHead(); //使用了另一个对象然后交换他们即可 list<T> tmp(l.begin(), l.end()); swap(tmp); } template <class Iterator> list(Iterator first, Iterator last) { CreateHead(); while (first != last) { push_back(*first); ++first; } } //现代写法 //这里不能使用引用传参，如果使用了就是舍己为人了 //传过来的对象就和this交换了，就失去了交换的意义 list<T>& operator=(list<T> l) { swap(l); return *this; } void swap(list<T>& l) { std::swap(_sz ,l._sz); std::swap(_head ,l._head); } ~list() { clear(); delete _head; _head = nullptr; } list(int n, const T& value = T()) { CreateHead(); while (n--) { push_back(value); } } // List Capacity size_t size()const { return _sz; } bool empty()const { return _sz == 0; } //迭代器 iterator begin() { //匿名显得简单 return iterator(_head->_next); } const_iterator begin() const { return const_iterator(_head->_next); } iterator end() { return iterator(_head); } const_iterator end() const { return const_iterator(_head); } //增删查改 void push_back(const T& val) { //node* newnode = new node(val); //node* tail = _head->_pre; _head tail newnode //tail->_next = newnode; //newnode->_pre = tail; //newnode->_next = _head; //_head->_pre = newnode; insert(end(), val); } void push_front(const T& val) { insert(begin(), val); } void pop_front() { erase(begin()); } void pop_back() { erase(--end()); } // List Access T& front() { assert(_sz >= 1); return (begin()._Node)->_val; } const T& front()const { assert(_sz >= 1); return (begin()._Node)->_val; } T& back() { assert(_sz >= 1); return ((--end())._Node)->_val; } const T& back()const { assert(_sz >= 1); return ((--end())._Node)->_val; } //在pos位置之前插入数据 iterator insert(iterator pos ,const T& val) { node* newnode = new node(val); node* cur = pos._Node; node* pre = cur->_pre; //链接 newnode pre cur newnode->_next = cur; newnode->_pre = pre; pre->_next = newnode; cur->_pre = newnode; ++_sz; return iterator(newnode); } iterator erase(iterator pos) { assert(pos != end()); node* cur = pos._Node; node* pre = cur->_pre; node* next = cur->_next; //pre next pre->_next = next; next->_pre = pre; delete cur; return iterator(next); } void clear() { //清理不清头节点 iterator it = begin(); while (it != end()) { it = erase(it); } } private: void CreateHead() { _head = new node(T()); _head->_next = _head; _head->_pre = _head; } node* _head; size_t _sz; };
3. list与vector的对比
vector
与
list
都是
STL
中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：
vector保证了高效存储，支持随机访问，同时使用vector就不关心插入删除效率
list则相反：大量插入和删除操作，不关心随机访问
711
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
