模拟准备
避免和库冲突，自己定义一个命名空间
namespace yx
{
template<class T>
struct ListNode
{
ListNode<T>* _next;
ListNode<T>* _prev;
T _data;
};
template<class T>
class list
{
typedef ListNode<T> Node;
public:
private:
Node* _head;
};
}这里的ListNode类为什么用struct呢？
知识点：
class：如果类里有公有，有私有，建议用
struct：如果一个类，全部成员不做访问限定，全公有，建议用
因为下面的list类是要经常访问ListNode的，所以建议用struct
模拟实现
模板ListNode的构造
封装节点的数据
template<class T>
struct ListNode
{
ListNode<T>* _next;
ListNode<T>* _prev;
T _data;
ListNode(const T& data)
:_next(nullptr)
, _prev(nullptr)
,_data(data)
{
}
};
list的构造
void list()
{
//哨兵位
_head = new Node;
_head->next = _head;
_head->prev = _head;
}定义一个哨兵位，自己指向自己。
push_back( )
尾插
void push_back(const T& x)
{
Node* newnode = new Node(x);
Node* tail == _head->prev;
tail->_next = newnode;
newnode->_prev - tail;
newnode->_next = _head;
}最后一个节点就是头节点的前一个
如果是一个空链表呢？满足条件么？
是可以的，这时候_head 和 tail都是哨兵位(head)
迭代器
说起迭代器，我们先考虑如何遍历链表吧。
我们是否可以像vector那样呢？
typedef Node* iterator;当然是不可以的。
vector的空间是连续的，而list的空间不连续，那我们如何获取Node*呢？
定义迭代器类
我们可以定义一个类,把节点_node封装起来，来弥补空间不连续的缺陷，能像vector那样一样来进行访问。
template<class T>
class ListIterator
{
typedef ListNode<T> Node;
Node* _node;
};template定义的模板参数只能供当前类或当前函数用
而且我们可以在这个类里重载想要的东西
使用时，我们就可以给每个类规范这个迭代器使用的名字，方便我们使用
typedef ListIterator<T> iterator;template<class T>
class ListIterator
{
typedef ListNode<T> Node;
typedef ListIterator<T> self; // 返回自己
Node* _node;
self& operator++()
{
_node = _node->_next;
return *this;//返回节点自己
}
T& operator*()
{
return _node->_data;//返回数据，数据类型为T
}
bool operator!=(const self& it)
{
return _node != it._node;
}
};iterator begin( ) 、 iterator end( )
我们实现了迭代器，我们来实现一下链表的头指针和尾指针吧
在list类里
iterator begin()
{
//iterator it(_head->_next);
//return it;
//我们采用匿名对象
return iterator(_head->_next);
}iterator end()
{
return iterator(_head;
}测试通过
operator->( )
T* operator->()
{
return &_node->_data;
}
我们来测试一下下面的代码
struct pos
{
int _row;
int _col;
pos(int row = 0, int col = 0)
:_row(row)
, _col(col)
{
}
};
void test2()
{
list<pos> lt1;
lt1.push_back(pos(100, 100));
lt1.push_back(pos(200, 100));
lt1.push_back(pos(300, 100));
list<pos>::iterator it = lt1.begin();
while (it != lt1.end())
{
cout << (*it)._row << ":" << (*it)._col << " ";
cout << it->_row << ":" << it->_col << " ";
++it;
}cout << endl;
}第一种用的是对象.成员
第二种指针->成员
第一种比较好理解，it调用operator*(),返回data数据，也就是pos，然后pos._row,pos._col来访问
第二种比较绕，这里为了可读性，省略可一个->，但如果写两个的话不符合语法，于是
cout << it.operator->()->_row << ":" << it.operator->()->_col << " ";
第一个->是operator重载的，而第二个是原生指针的解引用
const迭代器
不能是普通迭代器前面+const修饰。
如：const iterator const
const迭代器目标本身可以修改，指向的内容不能修改 ，
类似：const T* p
p可以修改，*p不能修改
因为T* 和 T&，这里我们可以写一个和迭代器一样的const迭代器类，但我们也可以类模板，传不同的参数，形成不同的类，让编译器帮我们实现。避免了写连个差不多重复的类，减少代码量
insert( )
//在pos前插入val
iterator insert(iterator pos, const T& val)
{
Node* pNewNode = new Node(val);
Node* pCur = pos._node;
pNewNode->_prev = pCur->_prev;
pNewNode->_next = pCur;
pNewNode->_prev->_next = pNewNode;
pCur->_prev = pNewNode;
return iterator(pNewNode);
}erase( )
//删除pos节点
iterator erase(iterator pos)
{
Node* pDel = pos._node;
Node* pRet = pDel->_next;
pDel->_prev->_next = pDel->_next;
pDel->_next->_prev = pDel->_prev;
delete pDel;
return iterator(pRet);
}clear()
void clear()
{
Node* cur = _head->_next;
while (cur != _head)
{
//从头开始删（从左向右）
_head->_next = cur->_next;
delete cur;
cur = _head->_next;
}
_head->_next = _head->_prev = _head;
}~list()
~list()
{
clear();
delete _head;
_head = nullptr;
}
