C++实现STL_List
今天用c++实现一个简易版的List。
首先定义链表的结点：
template
struct List_Node
{
T _data;
List_Node* _next;
List_Node* _prev;
List_Node(const T& x = T())
: _data(x)
, _next(nullptr)
, _prev(nullptr)
{}
}; 链表节点包含前驱指针和后驱指针，同时把构造函数写好，构造函数只需要为节点中的数据成员赋值，并将前驱节点和后驱节点置成空即可。这样一个节点的草图就完成了。
接下来实现List类，List类主要是完成对节点的操作，比如说链接前后节点，给链表插入数据，控制迭代器等等，List的数据成员设计成一个指向节点的指针，和STL保持一致。我们这里实现的链表是带哨兵位的双向循环链表，所以构造函数需要创建一个哨兵位节点，让
class List
{
typedef List_Node Node;
public:
List()
{
_head = new Node; //创建一个新结点作为哨兵位
_head->_next = _head;
_head->_prev = _head;
}
private:
Node* _head;
} 这时候的链表还只是一个空架子，只有一个哨兵位，其他啥都没有，我们想插入数据，就实现一个简单的尾插函数。
void push_back(const T& x)
{
Node* tail = _head->_prev;
Node* newnode = new Node(x);
tail->_next = newnode;
newnode->_next = _head;
newnode->_prev = tail;
_head->_prev = newnode;
}为了方便测试，我在类中写了一个print函数，用来打印我们的链表
尾插函数的测试：
void test1()
{
zy_List::List s1;
s1.push_back(1);
s1.push_back(2);
s1.push_back(3);
s1.push_back(4);
s1.push_back(5);
s1.push_back(6);
s1.print();
} 结果：
通过这里我们发现，我想打印链表还得自己在类里面写个函数，不然还访问不了，这怎么能行？于是乎我们就得自己写一写迭代器了。
List不同于vector，List的空间是不连续的，所以我们不可能用原生指针来控制链表。但是我们可以利用C++的特性让迭代器用起来和指针一摸一样。
翻看stl_list的源码不难发现，iterator(迭代器)是单独的一个类，其中存放着一个指向节点的指针
那么我们也模仿stl来实现一个自己的iterator类，这时候要思考的问题是iterator要实现什么功能？
最基本的肯定是获取节点数据以及遍历功能，我们先看我们是如何使用库中的List的
List s1;
s1.push_back(1);
s1.push_back(2);
s1.push_back(3);
s1.push_back(4);
s1.push_back(5);
s1.push_back(6);
auto it = s1.begin();
while (it != s1.end())
{
cout << *it << " ";
++it;
}
cout << endl; 获取节点数据需要的是解引用 * ，而遍历需要判断是否遍历到end位置以及++(让迭代器往后走)，以及begin(开始位置的迭代器),end(最后一个元素的下一个节点位置)和判断迭代器相等，这些符号可以用操作符重载来实现。
template
struct my_iterator
{
typedef my_iterator iterator;
typedef List_Node Node;
bool operator==(const iterator& it) const
{
return _node == it._node;
}
bool operator!=(const iterator& it) const
{
return _node != it._node;
}
iterator& operator++ ()
{
this->_node = _node->_next;
return *this;
}
iterator& operator--()
{
_node = _node->_prev;
return *this;
}
private:
Node* _node;
}; 在List类中添加begin和end函数(end是最后一个元素的下一个位置)
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}这样一个简易的iterator架子就搭好啦，可以遍历链表并且读写数据。
测试：
void test1()
{
zy_List::List s1;
s1.push_back(1);
s1.push_back(2);
s1.push_back(3);
s1.push_back(4);
s1.push_back(5);
s1.push_back(6);
auto it = s1.begin();
while (it != s1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
} 结果: 
这里有一个问题，如果我们想用const_iterator（常迭代器）怎么办? 直接把iterator的返回值改成const吗？但是返回值不同是不构成重载的啊，那怎么办呢？
这时候我们可以通过模板实例化来解决这个问题，即iterator和const_iterator使用不同的模板参数，当调用不同的iterator的时候my_iterator会实例化成不同的类型，也就会返回不同的值，emm讲的有点抽象，结合代码一起说吧
typedef my_iterator iterator;
typedef my_iterator const_iterator; 如果我们调用iterator，那么my_iterator的模板参数就是
完整代码：
#include
#pragma once
using namespace std;
namespace zy_List
{
template
struct List_Node
{
T _data;
List_Node* _next;
List_Node* _prev;
List_Node(const T& x = T())
: _data(x)
, _next(nullptr)
, _prev(nullptr)
{}
};
//定义一个iterator
template
struct my_iterator
{
typedef List_Node Node;
typedef my_iterator iterator;
//typedef my_iterator iterator;
my_iterator(Node* node)
: _node(node)
{}
bool operator==(const iterator& it) const
{
return _node == it._node;
}
bool operator!=(const iterator& it) const
{
return _node != it._node;
}
T& operator* ()
ref operator* ()
{
return (_node)->_data;
}
T& operator* ()
{
return (_node)->_data;
}
const T& operator*() const
{
return (_node)->_data;
}
iterator& operator++ ()
{
this->_node = _node->_next;
return *this;
}
iterator& operator--()
{
_node = _node->_prev;
return *this;
}
private:
Node* _node;
};
template
class List
{
typedef List_Node Node;
public:
typedef my_iterator iterator;
typedef my_iterator const_iterator;
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
void push_back(const T& x)
{
Node* tail = _head->_prev;
Node* newnode = new Node(x);
tail->_next = newnode;
newnode->_next = _head;
newnode->_prev = tail;
_head->_prev = newnode;
}
private:
Node* _head;
};
}