目录
[2.普通迭代器 +const迭代器的结合](#2.普通迭代器 +const迭代器的结合)
[3.构造+拷贝构造+析构+赋值重载 +清空](#3.构造+拷贝构造+析构+赋值重载 +清空)
接下来的日子会顺顺利利，万事胜意，生活明朗-----------林辞忧
引言
在前面的数据结构中已经实现了c版本的list-双向循环链表，但在c++中注重的是分装，对于操作进行封装处理，对于我们使用便是方便了不少，但模拟实现的话还是有许多要注意的细节点，尤其是list的迭代器较复杂，需要认真理解
一：STL源代码中关于list的成员变量的介绍
在源代码中使用一个头结点的指针来 模拟实现的，但在文档中只介绍list是一个双向链表的容器，并没有说明是否带哨兵位了，之时就得观察初始化函数和构造函数等来观察
所以从这里就可以看出list的结构就是一个带头循环双向链表，接下来我们就开始模拟实现
二：模拟实现list
1.基本结构
template<class T>//泛型编程
struct list_node
{
T _data;
list_node<T>* _prev;
list_node<T>* _next;
list_node(const T &x=T())//缺省值为匿名对象
:_data(x)
,_prev(nullptr)
,_next(nullptr)
{}
};
template<class T>
class list
{
typedef list_node<T> node;
public:
private:
node* head;
size_t size;//方便size()接口，省去便利的开销
};
2.普通迭代器 +const迭代器的结合
对于用迭代器来遍历list的数据，就不能像vector和string那样，直接使用，因为
list<int>::iterator it=lt1.begin();
while(it!=lt1.end())
{
cout<<*it<<" ";
++it;
}
cout<<endl;
对于这里面的*it和++it和it!=lt1.end()这些操作是不能直接支持的，因为*it是要取data的数据，++it就是要使_node=_node->next等，这些是和vector,string是不一样的，所以得自己手动支持，运用运算符重载+函数封装，我们先来观察源代码中的实现
我们先来实现普通迭代器
template<class T>
struct _list_iterator
{
typedef list_node<T> Node;
typedef _list_iterator<T> self;
Node* node;
_list_iterator(Node*node)
:_node(node)
{}
self& operator++()
{
_node = _node->next;
return *this;
}
self& operator--()
{
_node = _node->prev;
return *this;
}
self operator++(int)
{
self tmp(*this);
_node = _node->next;
return tmp;
}
self operator--(int)
{
self tmp(*this);
_node = _node->prev;
return tmp;
}
T& operator*()
{
return _node->data;
}
T* operator->()
{
return &_node->data;
}
bool operator!=(const self& s)
{
return _node != s._node;
}
bool operator==(const self& s)
{
return _node == s._node;
}
};
template<class T>
class list
{
typedef list_node<T> node;
public:
typedef _list_iterator<T> iterator;
iterator begin()
{
//return iterator(_head->_next);
return _head->_next;
}
iterator end()
{
return _head;
}
对于这个结构可以这样来理解
我们知道const对象使用的是const迭代器那么在iterator之前加const的话，这样const iterator指的是迭代器本身不能修改，但在遍历过程迭代器本身是要改变的，如++it等，所以不能这样写
应该为const_iterator这是一个重新定义的一个类型，要做到迭代器本身可以改变，但迭代器指向的内容不能改变
在原来普通迭代器的基础上重载出一份const迭代器的版本如
但这样的话对于普通迭代器和const迭代器两份代码是由许多相同的代码的，比较冗余，所以在源代码中提出了一份更好的解决方案来解决这个问题
在原来基础上多添加两个参数，这样对于同一个类模板，实例化参数不同就是不同的类型
对于上面的代码就要优化为更完善的代码，展示主要优化的代码
template<class T,class Ref,class Ptr>
struct _list_iterator
{
typedef list_node<T> Node;
typedef _list_iterator<T,Ref,Ptr> self;
Node* node;
Ref operator*()
{
return _node->data;
}
Ptr operator->()
{
return &_node->data;
}
typedef _list_iterator<T,T&,T*> iterator;
typedef _list_iterator<T, const T&, const T*> const_iterator;
//typedef __list_const_iterator<T> const_iterator;
iterator begin()
{
//return iterator(_head->_next);
return _head->_next;
}
iterator end()
{
return _head;
}
const_iterator begin()const
{
//return iterator(_head->_next);
return const_iterator(_head->_next);
}
const_iterator end()const
{
return const_iterator(_head);
}
对于->编译器是做处理的，将两个->优化为一个详细看代码及测试 用例3中
3.构造+拷贝构造+析构+赋值重载 +清空
构造时要使用带头循环双向循环链表的初始化操作，观看https://blog.csdn.net/Miwll/article/details/136593441?spm=1001.2014.3001.5502
void empty_init()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
_size = 0;
}
list()
{
empty_init();
}
list(const list<T>& t)//拷贝构造实现为深拷贝
{
empty_init();
for (auto e : t)
{
push_back(e);
}
}
/*list<int>& operator=(const list<int>& lt)
{
if (this != <)
{
clear();
for (auto e : lt)
{
push_back(e);
}
}
return *this;
}*/
void swap(list<T>& t)
{
std::swap(_head,t._head);
std::swap(_size, t._size);
}
list<int>& operator=(const list<int>& lt)
{
swap(lt);
return *this;
}
~list()
{
clear();
delete _head;
_head =nullptr;
}
void clear()
{
iterator it = begin();
while (it != end())
{
it = erase(it);
}
}
4.insert+erase+头尾插入删除
void push_back(const T& x)
{
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_front()
{
erase(begin());
}
void pop_back()
{
erase(--end());
}
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* newnode = new Node(x);
Node* prev = cur->_prev;
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
++_size;
return iterator(newnode);
}
iterator erase(iterator pos)
{
Node* cur = pos._node;
Node* next = cur->_next;
Node* prev = cur->_prev;
delete cur;
prev->_next = next;
next->_prev = prev;
--_size;
return iterator(next);
}
size_t size()
{
return _size;
}
5.打印不同数据类型的数据《使用模板加容器来完成》
使用模板来打印自定义类型数据，注意这里加的typename
list<T>未实例化的类模板，编译器不能去他里面去找
编译器就无法list<T>::const_iterator是内嵌类型，还是静态成员变量
前面加一个typename就是告诉编译器，这里是一个类型，等list<T>实例化
再去类里面去取
三：全部代码加测试用例链接
https://gitee.com/lin-ciyu/cplusplus/tree/master/my_list/my_list