STL之list介绍及实现（list接口模拟实现list）
Posted yumoz
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了STL之list介绍及实现（list接口模拟实现list）相关的知识，希望对你有一定的参考价值。
文章目录
1 什么是list？
- list是可以在常数范围内在任意位置插图和删除的序列式容器，并且支持前后双向迭代。
- list的低层本质是双向链表结构，且其节点存储在互不相关的独立节点中，节点通过指针访问其前面和后面的元素。
- list在插入和删除时效率高于vector。
- list不支持随机访问，但vector支持随机访问。
简单的list结果如图：
list中有_prev指针、_next指针 分别指向当前节点的上一个元素和下一个元素。
1.1 模拟实现预备知识
先定义一个list节点类：
//List节点类 （双向带头训练链表）
template<class T>
struct _list_node
{
T _val;
_list_node<T>* _next;
_list_node<T>* _prev;
_list_node(const T& val = T())
:_val(val)
, _prev(nullptr)
, _next(nullptr)
{}
};
list实现部分：
template<class T>
class list
{
typedef _list_node<T> node;
public:
typedef _list_iterartor<T, T&, T*> iterator;
typedef _list_iterartor<T, const T&, const T*> const_iterator;
//list模拟实现部分，在下文中有描述
private:
node* _head;
};
2 list原型测试与实现
2.1 构造函数（拷贝构造，赋值构造，析构）
构造函数测试：
模拟实现代码：
//默认的
list()
{
//_head = new node(T());
_head = new node;
_head->_next = _head;
_head->_prev = _head;
}
// 拷贝构造 copy(lt)
list(const list<T>& lt)
{
_head = new node;
_head->_next = _head;
_head->_prev = _head;
for (const auto& e : lt) //& 避免值过大
{
push_back(e);
}
}
// 深拷贝 copy = lt1; 传统写法
/* list<T>& operator=(const list<T>& lt)
{
if (this != <)
{
clear();
for (const auto& e : lt)
{
push_back(e);
}
}
return *this;
}*/
// copy = lt1; 现代写法
list<T>& operator=(list<T> lt)
{
swap(_head, lt._head);
return *this;
}
//析构
~list()
{
clear();
delete _head;
_head = nullptr;
}
2.2 迭代器
将迭代器理解成为一个指针，该指针指向list中某个节点。
模拟实现：
参考代码：
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);
}
2.3 capacity
list容器的容量测试：
capacity的部分实现代码：
（分析：当begin位置没有元素时，即begin()=end()时，list为空；关于求size，只需要使用迭代器依次迭代，并对size++，就可以实现size函数）
bool empty()
{
return begin() == end()；
}
size_t size()
{
size_t sz = 0;
iterator it = begin();
while (it != end())
{
++sz;
++it;
}
return sz;
}
2.4 modifiers
list容器的元素修改，有下图所示几种可能，我们分别进行分析。
2.4.1 assign
2.4.2 push_back/pop_back/push_front/pop_front
系统调用接口测试：
模拟实现代码：
备注：这里不做具体分析，因为下文已经对insert做了详细分析，这四个接口都可以根据insert接口来实现。
void push_back(const T& x)
{
//写法一
//node *newnode = new node(x);//new一个新节点
//node *tail = _head->_prev;//头指针的_prev指向尾
//tail->_next = newnode;
//newnode->_prev = tail;
//newnode->_next = _head;
//_head->_prev = newnode;
//写法二
insert(end(), x);//end()位置之前插入
}
void push_front(const T& x)
{
//写法一
//node *newnode = new node(x);
//node *next = _head->_next;
//_head->_next = newnode;
//newnode->_prev=_head;
//newnode->_next = next;
//next->_prev = newnode;
//写法二
insert(begin(), x);
}
void pop_back()
{
//写法一
/*assert(!empty());
node *popnode = _head->_prev;
node *prev = popnode->_prev;
_head->_prev;
prev->_next = _head;*/
//写法二
erase(--end()); //end是哨兵位，--之后是最后一个
}
void pop_front()
{
//写法一
/*assert(!empty());
node *popnode = _head->_next;
node *next = popnode->_next;
_head->_next = next;
next->_prev = _head;*/
//写法二
erase(begin());
}
2.4.3 insert
insert接口测试：
insert模拟实现：
（注：这里只实现插入一个字符）
参考代码：
//插入
void insert(iterator pos, const T& x)
{
assert(pos._pnode);
node* cur = pos._pnode;
node* prev = cur->_prev;
node* newnode = new node(x);
// prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
}
2.4.4 erase
erase接口测试：
模拟实现erase:
iterator erase(iterator pos)
{
assert(pos._pnode);
assert(pos != end());
node* prev = pos._pnode->_prev;
node* next = pos._pnode->_next;
delete pos._pnode;
prev->_next = next;
next->_prev = prev;
//删除完成之后，迭代器指针指向下一个位置，故返回iterator(next)
return iterator(next);//返回下一个位置迭代器
}
2.4.5 swap
2.4.6 resize
接口测试：
（模拟实现参考vector）
2.4.7 clear
clear接口测试：
模拟实现clear:
2.5 list 迭代器补充
上文中已经有了list的iterator，并能实现end，begin等操作。下面分析list迭代器必须有的几种能力：
有能力指向list的节点，并有能力进行正确的递增、递减、取值、成员存取等操作；
下面实现了：
- operator*
- operator->
- operator++(前置++，后置++)
- operator–（前置–，后置–）
- operator==
- operator!=
参考代码：
//读者看到此处，肯定有所收获，那么思考下面这个模板定义语句作用？？？
template<class T, class Ref, class Ptr>
struct _list_iterartor
{
typedef _list_node<T> node;
typedef _list_iterartor<T, Ref, Ptr> self;
node* _pnode;//迭代器内部必有一个普通指针，指向list的节点
//迭代器
_list_iterartor(node* pnode=nullptr)
:_pnode(pnode)
{}
//const 迭代器
_list_iterartor(const self& l)
:_pnode(l._pnode)
{}
//T& operator*()
Ref operator*()
{
return _pnode->_val;
}
//T* operator->()
Ptr operator->()
{
//return &(operator*());
return &_pnode->_val;
}
bool operator!=(const self& s) const
{
return _pnode != s._pnode;
}
bool operator==(const self& s) const
{
return _pnode == s._pnode;
}
// ++it -> it.operator++(&it)
self& operator++()
{
_pnode = _pnode->_next;
return *this;
}
// it++ -> it.operator++(&it, 0)
self operator++(int)
{
self tmp(*this);
_pnode = _pnode->_next;
return tmp;
}
self& operator--()
{
_pnode = _pnode->_prev;
return *this;
}
self operator--(int)
{
self tmp(*this);
_pnode = _pnode->_prev;
return tmp;
}
};
3 list迭代器失效
list迭代器失效，只会发生在erase函数中，不会发生在insert等操作。即插入才做不会导致list迭代器失效，只有在删除时才会失效。（并且失效的只是指向被删除节点的迭代器，其他迭代器不会受影响）。
下面一图看懂list迭代器失效：
其实，迭代器失效无非就是其指针出现了问题，所以我们操作时，必须了解指针在什么位置，起什么作用，这样才会避免迭代器失效发生。
附赠思考
上文中给出了一个问题：
//读者看到此处，肯定有所收获，那么思考下面这个模板定义语句作用？？？
为甚需要三个(class T, class Ref, class Ptr)？？？
template<class T, class Ref, class Ptr>
struct _list_iterartor
{
typedef _list_node node;
typedef _list_iterartor<T, Ref, Ptr> self;
node* _pnode;//迭代器内部必有一个普通指针，指向list的节点
我摘取了部分，供读者思考，分享。
参考文献：
- <<STL源码剖析>>，侯捷
- www.cplusplus.com list库
- 文中图片来自www.cplusplus.com
以上是关于STL之list介绍及实现（list接口模拟实现list）的主要内容，如果未能解决你的问题，请参考以下文章
[C/C++]详解STL容器3--list的功能和模拟实现（迭代器失效问题）
C++初阶：STL —— listlist的介绍及使用 | list的深度剖析及模拟实现 | list与vector的对比
C++初阶：STL —— listlist的介绍及使用 | list的深度剖析及模拟实现 | list与vector的对比
C++初阶：STL —— listlist的介绍及使用 | list的深度剖析及模拟实现 | list与vector的对比