STL容器 -- list的模拟实现（配详细注释）
目录
- 一、list容器是什么？
- 二、list的模拟实现
-
- 2.1 节点ListNode
- 2.2 成员变量
- 2.3 四大默认成员函数
-
- 2.3.1 构造函数
- 2.3.2 拷贝构造函数
- 2.3.3 赋值重载函数
- 2.3.4 析构函数
- 2.4 迭代器（重点内容）
- 2.5 insert函数
- 2.6 erase函数
- 2.7 尾插尾删、头插头删函数
- 三、list模拟实现代码汇总
一、list容器是什么？
C++ STL（Standard Template Library，标准模板库）提供了一组通用的模板类和函数，用于实现常用的数据结构和算法。其中之一是 std::list，它实现了一个双向链表。
std::list 是一个容器，用于存储一系列的值。与数组和向量等连续存储的容器不同，std::list 使用链表作为底层数据结构。每个节点都包含一个值，并且有指向前一个节点和后一个节点的指针，通过这些指针将节点连接起来。
由于使用链表作为底层结构，std::list 具有以下特点：
1、插入和删除效率高：在链表中插入和删除节点的操作非常高效，时间复杂度为O(1)。因为它不涉及元素的移动和内存的重新分配。
2、不支持随机访问：由于链表中的元素不是连续存储的，因此不能像数组或向量一样使用下标来随机访问元素。需要从链表的起始点或结束点沿着指针移动来访问元素，这会导致访问效率较低。
3、不占用连续内存：相比连续存储容器，链表不需要一块连续的内存空间，这使得它可以灵活地处理内存的分配和释放。
std::list 提供了一系列成员函数用于插入、删除和访问链表中的元素，如 push_back()、push_front()、pop_back()、pop_front()、insert()、erase() 等。此外，它还支持迭代器（iterator）用于遍历链表和访问元素。
二、list的模拟实现
2.1 节点ListNode
list存放的不仅仅是这个value本身，而是一个用类来封装value的节点，因为这是双向带头循环链表，所以节点里还需要有next和prev指针，方便查找该节点的下一个和上一个节点。节点的value的类型是不确定的，所以这是一个类模板。
//类模板的模板参数
template <class T>
struct ListNode
{
ListNode<T>* _prev;
ListNode<T>* _next;
T _val;
//需要提供构造函数，在新增节点时可以直接使用new，得到新结点
//这里的缺省值不能简单地写成0，因为T是不确定的类型，0只能代表
//整形，假如T是其它类型的话就不能是0了，所以我们要写成T类型的
//匿名对象，这样编译器就会自动地根据T的类型构造匿名对象作为
//缺省值了，如果T是自定义类型，编译器会自动调用默认构造函数
//构造匿名对象的，内置类型也有构造函数，整形默认构造成0
ListNode(const T& x = T())
:_prev(nullptr)
, _next(nullptr)
, _val(x)
{}
};
2.2 成员变量
对于list，最重要的成员变量就是需要一个哨兵位的头节点_head，这个_head节点不包含有效数据，仅仅作为链表的头，方便后续的插入删除等操作。其次，可以加一个_size成员，记录一个链表的长度。
private:
Node* _head;
size_t _size;
2.3 四大默认成员函数
2.3.1 构造函数
构造函数的目的是完成对成员变量的初始化工作，显然这里构造函数就是创建一个哨兵位的头节点即可。
void emptyInit()
{
_head = new Node;
//双向带头循环链表，没有元素的时候哨兵位的头节点
//的_next和_prev都是指向自己本身的
_head->_prev = _head;
_head->_next = _head;
_size = 0;
}
//构造函数
list()
{
//初始化
emptyInit();
}
2.3.2 拷贝构造函数
依旧存在深浅拷贝问题，为了避免链表中的节点被释放两次，依然需要深拷贝，即创建一个新的哨兵位的头节点，再把被拷贝的链表的每个节点都new出来，连接到这个新的哨兵位的头节点上去。
//拷贝构造
list(const list<T>& lt)
{
emptyInit();
//const_iterator it = lt.begin();
//while (it != lt.end())
//{
// push_back(*it);
// ++it;
//}
for (const auto& e : lt)
{
//把lt链表的所有节点都尾插到新的链表中即可
push_back(e);
}
}
2.3.3 赋值重载函数
void Swap(list<T>& lt)
{
std::swap(_head, lt._head);
std::swap(_size, lt._size);
}
//赋值重载(现代写法)
//利用传参的特性，传参时会调用拷贝构造函数构造一个临时的list，而这个
//list的内容就是新的链表所需要的，所以直接交换两者的成员函数即可，即
//交换哨兵位的头节点_head和_size即可
list<T>& operator=(list<T> lt)
{
Swap(lt);
return *this;
}
2.3.4 析构函数
析构函数是完成对链表中的节点的清理工作，我们需要把链表的节点一个一个地释放，最后再释放哨兵位的头节点_head。
void clear()
{
//需要一个一个地删除释放链表中的节点
iterator it = begin();
while (it != end())
{
//erase之后迭代器会失效，必须接受返回值更新it才能继续删
it = erase(it);
}
_size = 0;
}
~list()
{
//先清理释放链表中的有效节点
clear();
//再释放哨兵位的头节点_head
delete _head;
_head = nullptr;
}
2.4 迭代器（重点内容）
list容器的迭代器和前面的string和vector就不一样了，为什么呢？通过string和vector的性质可以发现，string和vector的底层都是用数组实现的，数组是具有连续的空间的，但是list就不同了，list底层是一个一个的节点连接起来的，并不是连续的空间，迭代器的要求是迭代器++能够指向下一个元素，迭代器“*”解引用能够找到这个迭代器指向的对象。
对于string和vector来说，原生指针就能做到++指向下一个元素，解引用能够得到指向的这个对象，但是对于list来说，++不能使迭代器指向下一个元素，因为空间不连续，解引用也不能得到我们想要的这个value，得到的是这个节点对象。所以对于list我们就不能直接用原生指针作为迭代器了。
那么我们要怎么设计这个迭代器呢？list之所以不能用原生指针直接作为迭代器，是因为链表的指针++不能找到下一个节点的地址，解引用不能得到这个value值，那么对于链表我们是怎么查找下一个节点的呢？那不就是_node=_node->_next吗？也就是说我们要使迭代器++的行为不再是单纯的指针++，而是使_node指针指向下一个，但是内置类型的++的行为是固定的啊，即对于内置类型的++操作的行为我们是不能改变的，这个时候C++中的运算符重载的意义就凸显了，内置类型的运算符的行为我们不能修改，但是自定义类型的运算符的行为我们是可以自定义的呀，你想怎么设计就怎么设计。
由此可知，我们要想使list的迭代器的++或者解引用等操作跟sting和vector一样，就需要用一个自定义的类封装指针，利用运算符重载控制迭代器的++，解引用等行为，设计出与string，vector一样的迭代器。所以在上层看似一样的迭代器，底层确实完全不一样的东西，而正是底层复杂的封装，才使得上层应用的时候都是一样的规则，所以看东西可不能只看表面哦！以下是迭代器的封装。
//T是T Ref是T&/const T& Ptr是T*/const T*
//为什么要传三个模板参数，主要是为了同一份代码实现iterator和const_iterator
//const_iterator是迭代器指向的内容不能修改，所以返回值需要是const版本的，
//当Ref是const T&时，*返回的是const T&,是不能修改的，当Ptr是const T*时，
//->返回值是const T*,指向的内容也是不能被修改的；符合const版本的迭代器。
//如果Ref是T&，Ptr是T*，就是普通版本的迭代器，传三个参数的目的是让编译器
//根据模板参数的类型实例化出普通迭代器和const迭代器
template <class T,class Ref, class Ptr>
struct __list_iterator
{
typedef ListNode<T> Node;
typedef __list_iterator<T,Ref,Ptr> self;
//list的迭代器只是对Node*指针进行了封装，形成了一个类，这样就可以
//通过运算符重载来控制迭代器++，解引用等行为
Node* _node;
public:
//迭代器的构造函数的参数只需要传一个指针即可
__list_iterator(Node* ptr)
:_node(ptr)
{}
//重载前置++，按照++的要求，迭代器++就指向下一个节点，所以
//_node=_node->_next就指向了下一个节点
self& operator++()
{
_node = _node->_next;
return *this;
}
//重载后置++，为了与前置++区分，需要加一个参数做占位符
//跟前置++一样的道理，只不过后置++的返回值是++前的结果
//所以需要先保存当前迭代器，再让迭代器往后走
self operator++(int)
{
self tmp(*this);
_node = _node->_next;
return tmp;
}
//重置前置--，--是找到前一个迭代器，所以_node=_node->_prev
self& operator--()
{
_node = _node->_prev;
return *this;
}
//与后置++原理类似，需要占位符做区分，并且需要先保存当前位置的迭代器
self operator--(int)
{
self tmp(*this);
_node = _node->_prev;
return tmp;
}
//*解引用目的是拿到节点中的value值，所以以引用的方式返回_node->_val即可
//对比原来的原生指针解引用拿到_node结构体，这里重载了*就能直接拿到value值
//达到了和string和vector一样的效果
Ref operator*()
{
return _node->_val;
}
//重载->，因为value也可能是一个自定义类型，箭头返回的是节点中value的地址，
//可以通过->访问这个自定义类型的里的成员
Ptr operator->()
{
return &_node->_val;
}
//必须带上const，因为调用operator!=的迭代器对象的参数是lt.end()，lt.end()
//本身是通过传值返回的，是iterator的一份临时拷贝，具有常性，所以必须用const接收
//比较两个迭代器是否相等，本质是比较迭代器里的_node指针是否相等
bool operator!=(const self& it)
{
return _node != it._node;
}
bool operator==(const self& it)
{
return _node == it._node;
}
};
所以要在list类中实现迭代器就变得非常简单了。
//双向带头循环链表的begin是哨兵位的头节点的_next
iterator begin()
{
//return iterator(_head->_next);
//单参数构造函数的类支持隐式类型的转换
//可以直接这样写，编译器会自动调用iterator
//的构造函数构造匿名对象返回
return _head->_next;
}
//因为这是双向带头循环链表，而end又是指最后一个元素的下一个位置，
//所以就是_head的位置
iterator end()
{
return _head;
}
//const版本
const_iterator begin() const
{
return _head->_next;
}
const_iterator end() const
{
return _head;
}
2.5 insert函数
iterator insert(iterator pos, const T& x)
{
//先创建一个新结点
Node* newNode = new Node(x);
//先把迭代器转换成节点的指针Node*，方便操作
Node* cur = pos._node;
//记录前一个节点
Node* prev = cur->_prev;
//更改连接关系，这个就easy了
prev->_next = newNode;
newNode->_prev = prev;
newNode->_next = cur;
cur->_prev = newNode;
//最后记得更新_size
++_size;
//同样存在隐式类型的转换
return newNode;
}
2.6 erase函数
iterator erase(iterator pos)
{
//断言，不能删除哨兵位的头节点
assert(pos != end());
//先把迭代器转换成Node*的指针，方便更改连接关系
Node* cur = pos._node;
//保存下一个节点
Node* next = cur->_next;
//保存前一个节点
Node* prev = cur->_prev;
//前一个节点与后一个节点连接起来即可
prev->_next = next;
next->_prev = prev;
//释放要删除的节点
delete cur;
cur = nullptr;
//最后记得--_size
--_size;
//同样存在隐式类型的转换
return next;
}
2.7 尾插尾删、头插头删函数
void push_back(const T& x)
{
//Node* newNode = new Node(x);
//if (newNode)
//{
// Node* tail = _head->_prev;
// tail->_next = newNode;
// newNode->_prev = tail;
// newNode->_next = _head;
// _head->_prev = newNode;
//}
//复用insert即可
insert(end(), x);
}
void pop_back()
{
//assert(_head->_prev != _head);
//Node* tail = _head->_prev;
//Node* tailPrev = tail->_prev;
//tailPrev->_next = _head;
//_head->_prev = tailPrev;
//delete tail;
//tail = nullptr;
//复用erase即可
erase(--end());
}
void push_front(const T& x)
{
//复用
insert(begin(), x);
}
void pop_front()
{
//复用
erase(begin());
}
三、list模拟实现代码汇总
#pragma once
#include 以上就是STL容器list常用接口的模拟实现的全部内容了，其实list还有很多接口，但是这些接口是常用的，其它的不常用的接口就不实现了。以上就是今天想要跟大家分享的内容，你学会了吗？如果这篇文章对你有所帮助，那么点点小心心，点点关注呗，后续还会持续更新C++的相关知识哦，我们下期见！！！！！