首先进行大框架  先写基本的结点类  有data next  prev

	template<class T>class ListNode//或者使用struct 就不用在写public声明公有{public://这里不仅仅是成员函数 成员变量也要公有化 ListNode<T>*  _next;ListNode<T>*  _prev;T _data;}

之后是链表list类的构造

template<class T>
class list
{typedef ListNode<T> Node;
public:list(){_head = new Node;_head->_next = _head;_head->_prev = _head;}
private:Node* _head;
};

私有成员是节点类型的指正 会在构造时指向我们的头节点

这里 我们创建的列表是带头双向循环链表  所以在初始化时让头节点的next 和prev指向自己  

接下来要模拟尾差 push_back  带头双向循环链表  是创建一个新节点  然后让新节点的prev指向尾节点  尾结点的next指向新节点 新节点的next指向头节点 头节点的prev指向新节点  

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->_prev = newnode;}

这里由于是双向带头循环链表 所以我们的尾节点就是头节点的prev指向的结点 所以我们不需要手动更新尾节点的位置  每次插入完成后 新节点会自动成为尾节点

这里在测试时会出现一些问题

1.按需实例化  那就是一些类和函数的一些语法问题 在没有被调用时系统不会检查报错 只有使用时实例化模版 这是才会报错

2.在上面的节点类中我们只写了成员函数而没有写构造函数 需要补充

3.关于私有公有的问题  我们的类在默认情况下是私有的  只有public下才能允许外界访问  而struct在默认情况下是全部共有的

template<class T>
class ListNode//或者使用struct 就不用在写public声明公有
{
public:
//这里不仅仅是成员函数 成员变量也要公有化 ListNode<T>*  _next;ListNode<T>*  _prev;T _data;ListNode(const T& data )//这里也可以用匿名对象写成全缺省: _next(nullptr), _prev(nullptr), _data(data) {}};	

这里我们上面的list在构造时并没有在头结点进行初始化赋值 而我们的push_bcak函数对新节点创立时进行了赋值  所以为了保持一致  要对头结点创建时进行赋值 也就是要有一个缺省值  但是这里不能给0  因为date 是T类型的  有可能是double 有可能是string  不能使用0赋值

那我们应该如何赋值给头结点呢 可以考虑给匿名对象

也可以在结点创建处参数写成全缺省

template<class T>
class ListNode//或者使用struct 就不用在写public声明公有
{
public:
//这里不仅仅是成员函数 成员变量也要公有化 ListNode<T>*  _next;ListNode<T>*  _prev;T _data;ListNode(const T& data = T() )//这里也可以用匿名对象写成全缺省: _next(nullptr), _prev(nullptr), _data(data) {}};	

这时进行测试

void list1()//在没有没有实例化以前检查是没有意义的 因为细节不会检查模版 只有实例化以后才会被检查
{//按需实例化 在没有实例化之前不会检查细节 同时只有调用这部分才会检查这部分（除了一些大的语法错误）在没实例化之前不会检查其对应部分list<int> l1;//不调用 就不实例化这个成员函数l1.push_back(1);l1.push_back(2);l1.push_back(1);l1.push_back(5);l1.push_back(10);l1.push_back(15);
}

这时push_back就可以正常使用了

接下来要模拟list迭代器  

迭代器++要到达下一个位置 但是这里的list节点不符合  list节点可以通过next指向到达下一个结点  

所以可以通过重载++实现迭代器模拟

template<class T>
class ListIterator//这里也存在私有的问题 需要使用public
{
public://这里也不用太担心公有化访问的 问题 不同的编译器下底层实现的代码是不同的 也就是名字不一定相同 同时正常一般是直接回调用迭代器 不会直接访问类成员typedef ListNode<T> Node;typedef ListIterator<T> Self;Node* _node;ListIterator(Node* node):_node(node){}//这个迭代器要不要写析构 不要  这个迭代器指向的空间是链表的 不希望被析构//这里也不需要拷贝构造 因为这里需要的就是浅拷贝 所以默认生成的拷贝构造就够用  所以默认生成的浅拷贝也是有些意义的 并不是完全没意义T& operator * () //每个类都能重载运算符 当重载号运算符之后就能控制一个类的行为{return _node->_data;}Self& operator ++(){_node = _node->_next;return *this;}
bool operator !=(const Self& it)
{return _node != it._node;
} 
};

这里迭代器的模拟重新使用了一个类来进行重载  这里的类成员就是一个结点指针  构造是对结点指针进行初始化构造   在一般的迭代器循环中 最常用到的是++  解引用   ！=   三个重载   这里先谢了这三个   这里的所有成员变量和函数 都是需要的  所以设置为公有public

实现这个类之后  在list类中typedef  iterator   这里为什么不直接使用listIterator  这是为了统一名称  

使代码使用更加流畅   同时在list类中实现  begin（）  end（） 成员函数

template<class T>
class list
{typedef ListNode<T> Node;public:
typedef ListIterator<T > iterator; //每个类都要使用iterator去规范迭代器  这样每个容器使用的都是iterator 这样使用起来方便 成本较低iterator begin()
{/*iterator it(_head->_next);return it;*/ //定义有名对象不如定义匿名对象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* newnode = new Node(x);Node* tail = _head->_prev;tail->_next = newnode;newnode->_prev = tail;newnode->_next = _head;_head->_prev = newnode;}private:Node* _head;
};

这里对于内置类型无法重载运算符 只有自定义类型才能重载运算符

	void list1()//在没有没有实例化以前检查是没有意义的 因为细节不会检查模版 只有实例化以后才会被检查{//按需实例化 在没有实例化之前不会检查细节 同时只有调用这部分才会检查这部分（除了一些大的语法错误）在没实例化之前不会检查其对应部分list<int> l1;//不调用 就不实例化这个成员函数l1.push_back(1);l1.push_back(2);l1.push_back(1);l1.push_back(5);l1.push_back(10);l1.push_back(15);list<int>::iterator it = l1.begin();while (it != l1.end()){cout << *it << " ";++it;}cout << endl;}

这里可以看到我们的初代迭代器是可以正常运行的

接下来我们继续通过重载的方式对迭代器进行进一步的完善  

template<class T>
class ListIterator//这里也存在私有的问题 需要使用public
{
public://这里也不用太担心公有化访问的 问题 不同的编译器下底层实现的代码是不同的 也就是名字不一定相同 同时正常一般是直接回调用迭代器 不会直接访问类成员typedef ListNode<T> Node;typedef ListIterator<T> Self;Node* _node;ListIterator(Node* node):_node(node){}//这个迭代器要不要写析构 不要  这个迭代器指向的空间是链表的 不希望被析构//这里也不需要拷贝构造 因为这里需要的就是浅拷贝 所以默认生成的拷贝构造就够用  所以默认生成的浅拷贝也是有些意义的 并不是完全没意义T& operator * () //每个类都能重载运算符 当重载号运算符之后就能控制一个类的行为{return _node->_data;}Self& operator ++(){_node = _node->_next;return *this;}Self& operator --()
{_node = _node->_prev;return *this;
}Self  operator ++(int)//这里是后置加加 参数中有int用来与前置++作区分
{Self tmp(*this);//这里返回的是加加之前的值的 所以需要提前保存一下_node = _node->_next;return *tmp;
}Self  operator --(int)
{Self tmp(*this);_node = _node->_prev;return *tmp;
}bool operator !=(const Self& it)
{return _node != it._node;
} bool operator ==(const Self& it)
{return _node == it._node;
}};

这里注意前置 与后置的 区别 前置返回的是引用的self  而后置则不引用直接返回self  同时为了区分前置和后置 在后置函数的括号中加了int   同时++是向下一个next移动  而--则是像下一个prev移动

这里要不要重载+和-  是不要的  因为+ 和-的效率非常低  如果要加10 那么就要向前走十次  

即便是在std库中也是没有重载+和-的

这里迭代器类是不需要析构函数的  这里并不希望迭代器释放   这里也不要写深拷贝构造 这里默认拷贝构造 和默认析构就够用

这里也支持修改 支持迭代器也就支持范围for

void list1()//在没有没有实例化以前检查是没有意义的 因为细节不会检查模版 只有实例化以后才会被检查
{//按需实例化 在没有实例化之前不会检查细节 同时只有调用这部分才会检查这部分（除了一些大的语法错误）在没实例化之前不会检查其对应部分list<int> l1;//不调用 就不实例化这个成员函数l1.push_back(1);l1.push_back(2);l1.push_back(1);l1.push_back(5);l1.push_back(10);l1.push_back(15);list<int>::iterator it = l1.begin();while (it != l1.end()){*it += 10;cout << *it << " ";++it;}cout << endl;for (auto e : l1){cout << e << " ";}cout << endl;
}

这里对迭代器进行进一步的加工

如果存在自定义类型pos类的链表来进行遍历

struct pos//这里需要提供默认构造
{int _row;int _col;pos(int row = 0, int col= 0)//这里写成全缺省提供默认构造:_row(row), _col(col){}
};

这是pos类的结构

可见一个pos中分别有横纵坐标

void list2()
{list<pos> l1;l1.push_back(pos(100,100));l1.push_back(pos(200, 200));l1.push_back(pos(300, 100));list<pos>::iterator it = l1.begin();while(it != l1.end()){cout << *it << " ";++it;}cout << endl;
}

这时我们的代码是无法正常运行的

正常运行的方法一  通过.来获取成员变量

void list2()
{list<pos> l1;l1.push_back(pos(100,100));l1.push_back(pos(200, 200));l1.push_back(pos(300, 100));list<pos>::iterator it = l1.begin();while(it != l1.end()){cout << (*it)._row << ":" << (*it). _col << endl;++it;}cout << endl;
}

方法2 也可以使用箭头->

void list2()
{list<pos> l1;l1.push_back(pos(100,100));l1.push_back(pos(200, 200));l1.push_back(pos(300, 100));list<pos>::iterator it = l1.begin();while(it != l1.end()){cout << it->_row << ":" << it-> _col << endl;++it;}cout << endl;
}

但是想要使用箭头 我们就需要再迭代器的类中重载->

	template<class T>class ListIterator//这里也存在私有的问题 需要使用public{public://这里也不用太担心公有化访问的 问题 不同的编译器下底层实现的代码是不同的 也就是名字不一定相同 同时正常一般是直接回调用迭代器 不会直接访问类成员typedef ListNode<T> Node;typedef ListIterator<T> Self;Node* _node;ListIterator(Node* node):_node(node){}//这个迭代器要不要写析构 不要  这个迭代器指向的空间是链表的 不希望被析构//这里也不需要拷贝构造 因为这里需要的就是浅拷贝 所以默认生成的拷贝构造就够用  所以默认生成的浅拷贝也是有些意义的 并不是完全没意义T& operator * () //每个类都能重载运算符 当重载号运算符之后就能控制一个类的行为{return _node->_data;}T* operator ->(){return &_node->_data;}Self& operator ++(){_node = _node->_next;return *this;}Self& operator --(){_node = _node->_prev;return *this;}Self  operator ++(int)//这里是后置加加 参数中有int用来与前置++作区分{Self tmp(*this);//这里返回的是加加之前的值的 所以需要提前保存一下_node = _node->_next;return *tmp;}Self  operator --(int){Self tmp(*this);_node = _node->_prev;return *tmp;}bool operator !=(const Self& it){return _node != it._node;}bool operator ==(const Self& it){return _node == it._node;}};

这时代码就可以自由使用

这里访问的其实有两箭头   :cout<< it .operator-> ()-> _row <<" :"<< it.operator->() ->_col;

第一个箭头返回 pos*  第二个箭头访问成员变量

但是为了美观 就省略为了一个箭头

const迭代器问题

这里先写一个func函数用来使用const迭代器进行遍历

void func(const list<int>&it)
{ list<int>::iterator it1 = it.begin();while (it1 != it.end()){cout << *it1 << " ";++it1;}cout << endl;
}

这里普通迭代器显然是无法使用 需要const迭代器  不能直接使用const修饰iterator  因为const迭代器类似于const指针  const迭代器的目的是想要迭代器指向的内容不能修改 而迭代器本身是可以修改的   直接使用const无法达到效果   

而想要迭代器指向的内容无法修改的核心是通过控制operator * 和 operator->返回的内容不能修改

而这里想要修改 就需要一个新的类 它与普通的迭代器类大体相似 但在一些关键地方上不同

 

template<class T>
class constListIterator//这里也存在私有的问题 需要使用public
{
public://这里也不用太担心公有化访问的 问题 不同的编译器下底层实现的代码是不同的 也就是名字不一定相同 同时正常一般是直接回调用迭代器 不会直接访问类成员typedef ListNode<T> Node;typedef constListIterator<T> Self;Node* _node;constListIterator(Node* node):_node(node){}//这个迭代器要不要写析构 不要  这个迭代器指向的空间是链表的 不希望被析构//这里也不需要拷贝构造 因为这里需要的就是浅拷贝 所以默认生成的拷贝构造就够用  所以默认生成的浅拷贝也是有些意义的 并不是完全没意义const T& operator * () //每个类都能重载运算符 当重载号运算符之后就能控制一个类的行为{return _node->_data;}const T* operator ->(){return &_node->_data;}Self& operator ++(){_node = _node->_next;return *this;}Self& operator --(){_node = _node->_prev;return *this;}Self  operator ++(int)//这里是后置加加 参数中有int用来与前置++作区分{Self tmp(*this);//这里返回的是加加之前的值的 所以需要提前保存一下_node = _node->_next;return *tmp;}Self  operator --(int){Self tmp(*this);_node = _node->_prev;return *tmp;}bool operator !=(const Self& it){return _node != it._node;}bool operator ==(const Self& it){return _node == it._node;}};

这里我们只修改类的名字为constiterator  同时对operator* 和operator->返回进行const修饰

同时在list类中 也要加入相对应的const_iterator别名  同时添加const迭代器使用begin和end成员函数

template<class T>
class list
{typedef ListNode<T> Node;public:typedef ListIterator<T > iterator; //每个类都要使用iterator去规范迭代器  这样每个容器使用的都是iterator 这样使用起来方便 成本较低typedef constListIterator<T> const_iterator;iterator begin(){/*iterator it(_head->_next);return it;*/ //定义有名对象不如定义匿名对象return iterator(_head->_next);}iterator end(){return iterator(_head);}const_iterator begin() const{/*iterator it(_head->_next);return it;*/ //定义有名对象不如定义匿名对象return const_iterator(_head->_next);}const_iterator end()  const{return const_iterator(_head);}list(){_head = new Node;_head->_next = _head;_head->_prev = _head;}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->_prev = newnode;}private:Node* _head;
};

这里进行测试

void func(const list<int>& it)
{list<int>::const_iterator it1 = it.begin();while (it1 != it.end()){cout << *it1 << " ";++it1;}cout << endl;
}void list3()
{list<int> l1;l1.push_back(1);l1.push_back(2);l1.push_back(1);func(l1);}

const迭代器已经可以正常运行

一个const迭代器 和一个普通的迭代器 两者之间非常的冗余 而且有很大的相似程度 这里我们可以用一个类来同时实现两个迭代器的功能

可以通过增加模版参数来实现

template<class T, class ref, class ptr>
class ListIterator//这里也存在私有的问题 需要使用public
{
public://这里也不用太担心公有化访问的 问题 不同的编译器下底层实现的代码是不同的 也就是名字不一定相同 同时正常一般是直接回调用迭代器 不会直接访问类成员typedef ListNode<T> Node;typedef ListIterator<T,ref,ptr> Self;Node* _node;ListIterator(Node* node):_node(node){}//这个迭代器要不要写析构 不要  这个迭代器指向的空间是链表的 不希望被析构//这里也不需要拷贝构造 因为这里需要的就是浅拷贝 所以默认生成的拷贝构造就够用  所以默认生成的浅拷贝也是有些意义的 并不是完全没意义ref operator * () //每个类都能重载运算符 当重载号运算符之后就能控制一个类的行为{return _node->_data;}ptr operator->() {return & _node->_data;}Self& operator ++(){_node = _node->_next;return *this;}Self& operator --(){_node = _node->_prev;return *this;}Self  operator ++(int)//这里是后置加加 参数中有int用来与前置++作区分{Self tmp(*this);//这里返回的是加加之前的值的 所以需要提前保存一下_node = _node->_next;return *tmp;}Self  operator --(int){Self tmp(*this);_node = _node->_prev;return *tmp;}bool operator !=(const Self& it){return _node != it._node;} bool operator ==(const Self& it){return _node == it._node;}
};

同时在list类中typedef时分别用不用的参数类型来使用不同的迭代器功能  通过模版参数 给不同的模版参数 让编译器来给我们写两个类（实例化）

typedef ListIterator<T ,T&,T*> iterator; //每个类都要使用iterator去规范迭代器  这样每个容器使用的都是iterator 这样使用起来方便 成本较低
//初始化
typedef ListIterator<T,const T&,const T*> const_iterator;
//typedef ListIterator<const T> const_iterator; 这种写法是不可取的 当这样写时虽然迭代器中的符合const迭代器的要求 但是我们链表中的Node是还是T 而迭代器中的是const T 在两者类型不用 实参是无法传给形参的

这样测试用例也是可以正常运行

最后在来模拟一下insert 和erase 

链表的insert 通过 对pos位置的结点 和 pos位置的prev指向节点之间插入一个新节点

这里创立prev节点 和cur节点 指针     prev指向cur指向节点的prev指向节点  cur指向pos位置的节点    同时有newnode作为新插入节点的指针  首先prev节点的next指向newnode  newnode节点的prev指向prev节点  newnode节点的next指向cur的结点  cur节点的prev 指向newnode节点

这时就插入成功了 

且这里的insert是没有迭代器失效的 但是库中仍然给了返回值

iterator insert (iterator pos , const T&x)
{Node* cur = pos._node;//这里pos指向的迭代器没有改变 所以没有失效  但是库中仍然返回了一个值 Node* prev = cur->_prev;Node* newnode = new Node(x);prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);
}

erase函数则是通过创建 prev和next指针分别指向 pos位置上一个节点 和下一个结点来进行连接

同时将now指向的pos位置的节点通过delete进行删除  这里存在迭代器失效  且只有pos位置的迭代器失效 其他位置正常  这里通过给返回值返回删除前下一个位置 来更新迭代器  这里通过断言 防止将头结点删掉

iterator erase(iterator pos)//这里存在迭代器失效的问题 
{assert(pos != end());Node* now = pos._node;Node* prev = now->_prev;Node* next = now->_next;prev->_next = next;next->_prev = prev;delete now;return iterator(next);
}

之后通过代码复用 通过insert 和erase可以快速写出 push_back  push_front  pop_back pop_front

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->_prev = newnode;*/insert(end(),x);
}
void pop_back()//持续的删除是有可能会将哨兵位给删掉的 所以要加断言  断言在erase函数
{erase(--end());
}void push_front(const T& x)
{insert(begin(),x);
}
void pop_front()
{erase(begin());
}