1.迭代器
1.1正向迭代器
正向迭代器是用一个类封装的，迭代器类。例如：在vector，string中的迭代器就相当于一个指针，在list类中用一个类来封装一个节点，实质上也还是一个指针，迭代器就相当于指向一个节点的指针。
现在以list为例子，list的迭代器，代码如下：
//迭代器类
// 一个链表指针用迭代器封装，实质上还是一个指针
//迭代器也就相当于指向一个节点的指针
//第一种解决const类型的迭代器
//const迭代器类
template<class T>
struct ListConstIterator
{
typedef ListNode<T> Node;
typedef ListIterator<T> Self;
Node* _node; //一个迭代器节点
//迭代器构造
ListConstIterator(Node* node) :_node(node)
{}
++it
前置++，返回++以后的值
Self& operator++()
{
_node = _node->_next;
return *this;
}
it++
后置++
Self operator++(int)
{
Self tmp(*this);//浅拷贝，即两个迭代器指针指向同一个空间，直接应用默认拷贝构造
_node = _node->_next;
return tmp;//拷贝
}
--it
Self& operator--()
{
//向前走
_node = _node->_prev;
return *this;
}
it--
Self operator--(int)
{
Self tmp(*this);
_node = _node->_prev;
return tmp;
}
*it
解引用，返回的是数据
T& operator*()
{
return _node->data;
}
==
比较两个迭代器相等，即比较迭代器的位置（引用/地址）相同
bool operator==(const Self& it)
{
return _node == it._node;
}
//!=
bool operator!=(const Self& it)
{
return _node != it._node;
}
//->
//返回的是数据的地址
T* operator->()
{
return &_node->data;
}
};
1.3 正向const迭代器
const迭代器和普通迭代器区别是： const迭代器指向的内容不能被修改！即为const_iterator begin() const，相当于const int *p
而迭代器器本身不能修改是const iterator begin()，也就相当于int * const p
所以普通迭代器和const迭代器的代码差异只在解引用是有差别
第一种解决方法是在普通迭代器的基础上再写一个const迭代器类，代码如下：
普通迭代器：
//const迭代器类
template<class T>
struct ListConstIterator
{
typedef ListNode<T> Node;
typedef ListIterator<T> Self;
Node* _node; //一个迭代器节点
//迭代器构造
ListConstIterator(Node* node) :_node(node)
{}
++it
前置++，返回++以后的值
Self& operator++()
{
_node = _node->_next;
return *this;
}
it++
后置++
Self operator++(int)
{
Self tmp(*this);//浅拷贝，即两个迭代器指针指向同一个空间，直接应用默认拷贝构造
_node = _node->_next;
return tmp;//拷贝
}
--it
Self& operator--()
{
//向前走
_node = _node->_prev;
return *this;
}
it--
Self operator--(int)
{
Self tmp(*this);
_node = _node->_prev;
return tmp;
}
*it
解引用，返回的是数据
T& operator*()
{
return _node->data;
}
==
比较两个迭代器相等，即比较迭代器的位置（引用/地址）相同
bool operator==(const Self& it)
{
return _node == it._node;
}
//!=
bool operator!=(const Self& it)
{
return _node != it._node;
}
//->
//返回的是数据的地址
T* operator->()
{
return &_node->data;
}
};
const迭代器
//第一种解决const类型的迭代器
//const迭代器类
template<class T>
struct ListConstIterator
{
typedef ListNode<T> Node;
typedef ListConstIterator<T> Self;
Node* _node; //一个迭代器节点
//迭代器构造
ListConstIterator(Node* node) :_node(node)
{}
++it
前置++，返回++以后的值
Self& operator++()
{
_node = _node->_next;
return *this;
}
it++
后置++
Self operator++(int)
{
Self tmp(*this);//浅拷贝，即两个迭代器指针指向同一个空间，直接应用默认拷贝构造
_node = _node->_next;
return tmp;//拷贝
}
--it
Self& operator--()
{
//向前走
_node = _node->_prev;
return *this;
}
it--
Self operator--(int)
{
Self tmp(*this);
_node = _node->_prev;
return tmp;
}
*it
解引用，返回的是数据
const T& operator*()
{
return _node->data;
}
==
比较两个迭代器相等，即比较迭代器的位置（引用/地址）相同
bool operator==(const Self& it)
{
return _node == it._node;
}
//!=
bool operator!=(const Self& it)
{
return _node != it._node;
}
//->
//返回的是数据的地址
const T* operator->()
{
return &_node->data;
}
};
第二种解决方法:由于const迭代器和普通迭代器只有解引用重载的返回值不一样
//普通迭代器
解引用，返回的是数据
T& operator*()
{
return _node->data;
}
//->
//返回的是数据的地址
T* operator->()
{
return &_node->data;
}
//const迭代器
解引用，返回的是数据
const T& operator*()
{
return _node->data;
}
//->
//返回的是数据的地址
const T* operator->()
{
return &_node->data;
}
由于两个代码差别不大，只是重载的返回值不一样。第一种也会导致代码冗余，所以用模板来解决以下的问题，代码如下：
template<class T,class Ref,class Ptr>
struct ListIterator
{
typedef ListNode<T> Node;
typedef ListIterator<T,Ref,Ptr> Self;
Node* _node; //一个迭代器节点
//迭代器构造
ListIterator(Node *node):_node(node)
{}
++it
前置++，返回++以后的值
Self& operator++()
{
_node = _node->_next;
return *this;
}
it++
后置++
Self operator++(int)
{
Self tmp(*this);//浅拷贝，即两个迭代器指针指向同一个空间，直接应用默认拷贝构造
_node = _node->_next;
return tmp;//拷贝
}
--it
Self& operator--()
{
//向前走
_node = _node->_prev;
return *this;
}
it--
Self operator--(int)
{
Self tmp(*this);
_node = _node->_prev;
return tmp;
}
*it
解引用，返回的是数据
//T& operator*()
Ref operator*()
{
return _node->data;
}
==
比较两个迭代器相等，即比较迭代器的位置（引用/地址）相同
bool operator==(const Self& it)
{
return _node == it._node;
}
//!=
bool operator!=(const Self& it)
{
return _node != it._node;
}
//->
//返回的是数据的地址
//T* operator->()
Ptr operator->()
{
return &_node->data;
}
};
template<class T>
class list
{
public:
//重定义节点类名
typedef ListNode<T> Node;
private:
Node* _head;//哨兵位
size_t _size;//链表中节点的个数
public:
......
//第二种方法解决const迭代器类
typedef ListIterator<T,T&,T*> iterator;
typedef ListIterator<T,const T&,const T*> const_iterator;
//迭代器的引用
iterator begin()
{
//iterator it(_head->_next);//有名对象
//return it;
return iterator(_head->_next);//这是应用的是一个匿名对象
}
iterator end()
{
return iterator(_head);
}
//const迭代器，需要迭代器不能修改，还是迭代器指向的内容？
// 迭代器指向的内容不嫩被修改！ const iterator不是我们需要的const迭代器
//以下是迭代器本身不能修改
//const iterator begin()错误
const_iterator begin() const
{
//iterator it(_head->_next);//有名对象
//return it;
return const_iterator(_head->_next);//这是应用的是一个匿名对象
}
const_iterator end() const
{
return const_iterator(_head);
}
};
1.3反向迭代器和反向const迭代器
在我们主观意识上，正向迭代器的begin指向的是除去哨兵位的第一个节点，end则是指向最后一个节点下一个节点（即哨兵位头节点）。而我们也会觉得rbegin则是指向最后一个数据，rend指向第一个节点的上一个节点（即哨兵位头节点），如图
但是，在c++库中我们则见到的是将begin和rend指向的第一个节点，end和rbegin都指向哨兵位头节点，如图
但是库中的解引用时，会是先++，再解引用
//解引用
Ref operator*()
{
//return *_it;
//解引用的是前一个
Iterator tmp = _it;
return *(--tmp);
}
#include<iostream>
#include<vector>
#include<string>
using namespace std;
//所有容器的反向迭代器
//迭代器适配器
//给我vector<T>::iterator,list<int>::iterator
//适配出相应的反向迭代器
//本来，每个容器都要写一个反向迭代器的类，但是自己写，太费劲了
template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
typedef ReverseIterator<Iterator, Ref, Ptr> Self;//重命名
Iterator _it;
//构造
//反向迭代器封装一个正向迭代器
ReverseIterator(Iterator it) :_it(it)
{}
Ref operator*()
{
//return *_it;
//解引用的是前一个
Iterator tmp = _it;
return *(--tmp);
}
Ptr operator->()
{
//return _it.operator->();
return &(operator*());
}
//++调用迭代器中的--
Self& operator++()
{
--_it;
return *this;
}
Self& operator--()
{
++_it;
return *this;
}
bool operator!=(const Self& s)
{
return _it != s._it;
}
};
