🍔前言：
在C++的世界中，有一种数据结构，它不仅像一个神奇的瑰宝匣，还像一位能够在数据的海洋中航行的智慧舵手。这就是C++中的list，一个引人入胜的工具，它以一种优雅而强大的方式管理着数据的舞台。想象一下，你有一个能够轻松操纵、轻松操作的魔法列表，让你的编程之旅变得轻松而令人愉悦。让我们一同揭开list的神秘面纱，深入探索这个双向链表的奇妙世界。
目录
[list iterator的使用](#list iterator的使用)
[list capacity](#list capacity)
[list element access](#list element access)
[list modifiers](#list modifiers)
list的介绍及使用
list的介绍
-
list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
-
list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
-
list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
-
与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
-
与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
list的文档介绍 
https://legacy.cplusplus.com/reference/list/list/
list的使用
list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口。
list的构造
|---------------------------------------------------------------|---------------------------------|
| 构造函数（ (constructor)） | 接口说明 |
| list (size_type n, const value_type& val = value_type()) | 构造的list中包含n个值为val的元素 |
| list() | 构造空的list |
| list (const list& x) | 拷贝构造函数 |
| list (InputIterator first, InputIterator last) | 用[first, last)区间中的元素构造list |
cpp
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <list>
#include <vector>
// list的构造
void TestList1()
{
list<int> l1; // 构造空的l1
list<int> l2(4, 100); // l2中放4个值为100的元素
list<int> l3(l2.begin(), l2.end()); // 用l2的[begin(), end()）左闭右开的区间构造l3
list<int> l4(l3); // 用l3拷贝构造l4
// 以数组为迭代器区间构造l5
int array[] = { 16,2,77,29 };
list<int> l5(array, array + sizeof(array) / sizeof(int));
// 列表格式初始化C++11
list<int> l6{ 1,2,3,4,5 };
// 用迭代器方式打印l5中的元素
list<int>::iterator it = l5.begin();
while (it != l5.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// C++11范围for的方式遍历
for (auto& e : l5)
cout << e << " ";
cout << endl;
}list的构造与STL中vector、string构造大同小异，都是有构造空对象，构造的list中包含n个值为val的元素，拷贝构造以及迭代器构造。
list iterator的使用
此处，大家可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。
|-----------------|-----------------------------------------------------------------------------|
| 函数声明 | 接口说明 |
| begin+end | 返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器 |
| rbegin+rend | 返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置 |
cpp
// list迭代器的使用
// 注意：遍历链表只能用迭代器和范围for
void PrintList(const list<int>& l)
{
// 注意这里调用的是list的 begin() const，返回list的const_iterator对象
for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it)
{
cout << *it << " ";
// *it = 10; 编译不通过
}
cout << endl;
}
void TestList2()
{
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list<int> l(array, array + sizeof(array) / sizeof(array[0]));
// 使用正向迭代器正向list中的元素
// list<int>::iterator it = l.begin(); // C++98中语法
auto it = l.begin(); // C++11之后推荐写法
while (it != l.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// 使用反向迭代器逆向打印list中的元素
// list<int>::reverse_iterator rit = l.rbegin();
auto rit = l.rbegin();
while (rit != l.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
}**【注意】
- begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
- rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动**
3.迭代器都会提供两个版本，一个是无const修饰的，一个是有const修饰的
list capacity
|-----------|----------------------------------|
| 函数声明 | 接口说明 |
| empty | 检测list是否为空，是返回true，否则返回false |
| size | 返回list中有效节点的个数 |
cpp
// list::empty
#include <iostream>
#include <list>
int main ()
{
std::list<int> mylist;
int sum (0);
for (int i=1;i<=10;++i) mylist.push_back(i);
while (!mylist.empty())
{
sum += mylist.front();
mylist.pop_front();
}
std::cout << "total: " << sum << '\n';
return 0;
}
cpp
// list::size
#include <iostream>
#include <list>
int main ()
{
std::list<int> myints;
std::cout << "0. size: " << myints.size() << '\n';
for (int i=0; i<10; i++) myints.push_back(i);
std::cout << "1. size: " << myints.size() << '\n';
myints.insert (myints.begin(),10,100);
std::cout << "2. size: " << myints.size() << '\n';
myints.pop_back();
std::cout << "3. size: " << myints.size() << '\n';
return 0;
}这两个函数都是与list中成员有关的函数，我们学会后可以方便快速使用。
list element access
|-----------|------------------------|
| 函数声明 | 接口说明 |
| front | 返回list的第一个节点中值的引用 |
| back | 返回list的最后一个节点中值的引用 |
cpp
// list::front
#include <iostream>
#include <list>
int main ()
{
std::list<int> mylist;
mylist.push_back(77);
mylist.push_back(22);
// now front equals 77, and back 22
mylist.front() -= mylist.back();
std::cout << "mylist.front() is now " << mylist.front() << '\n';
return 0;
}
cpp
// list::back
#include <iostream>
#include <list>
int main ()
{
std::list<int> mylist;
mylist.push_back(10);
while (mylist.back() != 0)
{
mylist.push_back ( mylist.back() -1 );
}
std::cout << "mylist contains:";
for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end() ; ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
}list modifiers
|------------|------------------------------|
| 函数声明 | 接口说明 |
| 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中的有效元素 |
cpp
// list插入和删除
// push_back/pop_back/push_front/pop_front
void TestList3()
{
int array[] = { 1, 2, 3 };
list<int> L(array, array + sizeof(array) / sizeof(array[0]));
// 在list的尾部插入4，头部插入0
L.push_back(4);
L.push_front(0);
PrintList(L);
// 删除list尾部节点和头部节点
L.pop_back();
L.pop_front();
PrintList(L);
}
// insert /erase
void TestList4()
{
int array1[] = { 1, 2, 3 };
list<int> L(array1, array1 + sizeof(array1) / sizeof(array1[0]));
// 获取链表中第二个节点
auto pos = ++L.begin();
cout << *pos << endl;
// 在pos前插入值为4的元素
L.insert(pos, 4);
PrintList(L);
// 在pos前插入5个值为5的元素
L.insert(pos, 5, 5);
PrintList(L);
// 在pos前插入[v.begin(), v.end)区间中的元素
vector<int> v{ 7, 8, 9 };
L.insert(pos, v.begin(), v.end());
PrintList(L);
// 删除pos位置上的元素
L.erase(pos);
PrintList(L);
// 删除list中[begin, end)区间中的元素，即删除list中的所有元素
L.erase(L.begin(), L.end());
PrintList(L);
}
// resize/swap/clear
void TestList5()
{
// 用数组来构造list
int array1[] = { 1, 2, 3 };
list<int> l1(array1, array1 + sizeof(array1) / sizeof(array1[0]));
PrintList(l1);
// 交换l1和l2中的元素
list<int> l2;
l1.swap(l2);
PrintList(l1);
PrintList(l2);
// 将l2中的元素清空
l2.clear();
cout << l2.size() << endl;
}这些都是list中一些重要接口，我们一定要牢记。list中还有一些操作，需要用到时大家可参阅list的文档说明。
list的模拟实现
模拟实现list的准备
要模拟实现list，必须要熟悉list的底层结构以及其接口的含义，所以我们先从STL源码(SGI版本)开始学习。我们要进行模拟，首先得知道底层的数据类型都有什么。
首先我们知道list是带头双向链表，所以每一处都有一个节点，所以C++肯定会对节点进行封装。
源码中创建了节点的模板，使用struct对节点进行封装处理。因为我们要访问节点，所以使用struct进行类定义而不是class，class默认类部成员都是私有，struct默认类部成员都是公有。
接下来应该看list的结构，看list中的成员变量有什么？
list类中只有一个成员，并且这个成员是节点的指针。
我们已经大致了解了list的类型，接下来我们开始模拟实现list。
封装节点------第一个封装
cpp
#include<assert.h>
#include<iostream>
using namespace std;
namespace why
{
template<class T>
struct list_node
{
list_node<T>* _next;
list_node<T>* _prev;
T _data;
list_node(const T& x = T())
:_next(nullptr)
, _prev(nullptr)
, _data(x)
{}
};创建一个节点类进行封装， 我们在这里没有源码中那么繁琐，不需要定义空指针进行强制类型转换，而是直接使用list_node<T>*进行指针声明。在这里我们也需要构造函数，默认构造函数对指针不能很好的初始化。
创建list类------第二个封装
cpp
template<class T>
class list
{
typedef list_node<T> node;
public:
typedef __list_iterator<T,T&,T*> iterator;
typedef __list_iterator<T, const T&,const T*> const_iterator;
list()
{
_head = new node;
_head->_next = _head;
_head->_prev = _head;
}
private：
node* _head;
}；list是一个双向循环链表 ，所以它只需要一个指针 ，便可以遍历整个链表并且回到原来的位置。为此我们可以设计一个头节点为list的起始节点，这个头节点不含任何数据，它只是作为一个空的节点而已，所以我们创建一个_head指针作为头节点。
push_back函数模拟
push_back函数是在list的末尾进行插入数据，就与C语言中的数据结构一样进行插入即可。
cpp
void push_back(const T& x)
{
node* tail = _head->_prev;
//创建新节点
node* newnode = new node(x);
tail->_next = newnode;
newnode->_prev = tail;
newnode->_next = _head;
_head->_prev = newnode;
}
创建一个新节点，让新节点的_prev指向尾部，_next指向头节点。让头节点的_prev指向新节点，尾部节点的_next指向新节点即可。
创建迭代器类------第三个封装
我们现在已经可以将数据尾插到list中去了，但是如何进行遍历打印呢？在list中因为每一个节点的空间是不连续的，所以不能重载[]进行下标访问。而且在string与vector中都使用的是原生指针，所以可以进行++，!=，*()操作，但是在list中却不能使用。因此list的迭代器应该是自定义类型对原生指针的封装，模拟指针的行为，才能有正确的递增，递减，取值，成员取用的行为。
我们需要通过源码进行分析，然后创建一个迭代器的类自己进行重载正确使用。这里推荐大家去看一下源码。
SGI版本list源码https://github.com/karottc/sgi-stl
总结如下：
递增：正确的找到其next的地址
递减：正确的找到其prev的地址
取值：当前节点的取值
成员取用：当前节点的成员
cpp
template<class T,class Ref,class Ptr>
struct __list_iterator
{
typedef list_node<T> node;
typedef __list_iterator<T, Ref,Ptr> self;
node* _node;
__list_iterator(node* n)
:_node(n)
{}
Ref& operator*()
{
return _node->_data;
}
self operator++()
{
_node = _node->_next;
return *this;
}
self operator++(int)
{
self tmp(_node);
_node = _node->_next;
return tmp;
}
self operator--()
{
_node = _node->_prev;
return *this;
}
self operator--(int)
{
self tmp(_node);
_node = _node->_prev;
return tmp;
}
Ptr operator->()
{
return &_node->_data;
}
bool operator!=(const self& s)
{
return _node != s._node;
}
bool operator==(const self& s)
{
return _node == s._node;
}
};类模板中为什么有三个参数呢？因为*()与->进行重载时会面临两种情况，有无const修饰，所以我们可以通过模板来传递此重载是否有无const。如果不理解这种情况，我们可以分开写有无const的情况，但是这样需要写4种情况，造成代码的冗余。
这时我们就可以使用迭代器对list进行遍历打印操作了，可以使用范围for。
cpp
void test1()
{
list<int> ll;
ll.push_back(1);
ll.push_back(1);
ll.push_back(1);
ll.push_back(1);
list<int>::iterator it = ll.begin();
while (it != ll.end())
{
cout << *it << ' ';
++it;
}
cout << endl;
}注意：这里我们在给迭代器it赋值时调用了默认拷贝构造函数，因为这里不需要深拷贝。但是在vector，string的情况来说浅拷贝会报错，但是这里为什么没有报错呢？因为在迭代器类中我们并没有写析构函数，所以不会进行多次重复释放空间。
我们这里是不需要写析构函数的，因为迭代器创建的类只是为了更好的适应迭代器的操作，因为list是不连续的空间，我们迭代器指向的空间全部都是节点的，我们只是使用一下而已不需要进行释放操作，释放是list的事情。
begin与end函数模拟
cpp
iterator begin()
{
//iterator it(_head->_next);
//return it;
return iterator(_head->_next);
}
const_iterator begin() const
{
return const_iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
const_iterator end() const
{
//iterator it(_head->_next);
//return it;
return const_iterator(_head);
}begin与end都有两个版本，const与非const。
insert函数模拟实现
插入函数非常简单，在迭代器pos位置进行插入即可。
cpp
void insert(iterator pos, const T& x)
{
node* cur = pos._node;
node* prev = cur->_prev;
node* newnode = new node(x);
prev->_next = newnode;
newnode->_prev = prev;
cur->_prev = newnode;
newnode->_next = cur;
}将插入的数进行前端后端相连即可。
前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。
erase函数模拟实现
我们可以看出erase是有返回值的，就是避免迭代器失效的原因，而且绝对不能删除哨兵位节点，所以得使用断言。
cpp
iterator erase(iterator pos)
{
assert(pos != end());
node* prev = pos._node->_prev;
node* cur = pos._node->_next;
prev->_next = cur;
cur->_prev = prev;
delete pos._node;
return iterator(cur);
}写完insert与erase我们就可以对其进行复用，pop_back、pop_front、push_back、push_front就是进行了首插、首删、尾插、尾删。
cpp
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
void push_back(const T& x)
{
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}clear函数以及析构函数的实现
clear函数就是将list置空，所以我们可以复用erase进行逐一删除即可。
cpp
void clear()
{
iterator it = begin();
while (it != end())
{
erase(it++);
//it = erase(it);
}
}不能使用erase(it)，会导致迭代器失效
析构函数将空间全部释放置空：
cpp
~list()
{
clear();
delete _head;
_head = nullptr;
}其余函数接口的实现
迭代器初始化：
cpp
template <class Iterator>
list(Iterator first, Iterator last)
{
empty_init();
while (first != last)
{
push_back(*first);
++first;
}
}拷贝构造函数：
cpp
void swap(list<T>& tmp)
{
std::swap(_head, tmp._head);
}
list(const list<T>& lt)
{
_head = new node;
_head->_next = _head;
_head->_prev = _head;
list<T> tmp(lt.begin(), lt.end());
swap(tmp);
}我们使用现代写法进行偷懒，我们使用迭代器初始化一个临时对象tmp，将tmp与目标进行交换即可。
赋值重载构造：
cpp
list<int>& operator=(list<T> lt)
{
swap(lt);
return *this;
}我们使用传值时会进行拷贝构造临时对象lt，将lt与目标进行交换即可，属于窃取劳动成果！
在我们的"C++ List探秘之旅"中，我们像是一群探险者，勇敢地穿越了C++编程的密林，发现了list这个神奇的宝藏。现在，当我们回望这段旅程时，或许你已经领略到了在数据操控的掌声中，list是如何成为代码交响乐团的一部分。这并不是终点，而是一个新的起点。在C++的舞台上，list为你打开了通往更高层次编程乐趣的大门，希望大家可以通过本文走的更高。感谢观看！！！